Author: [log in to unmask]
Date: Tue May 5 14:05:24 2015
New Revision: 2905
Log:
Create detector-model module on HPS Java branch. HPSJAVA-499
Added:
java/branches/HPSJAVA-499/detector-model/
java/branches/HPSJAVA-499/detector-model/pom.xml
java/branches/HPSJAVA-499/detector-model/src/
java/branches/HPSJAVA-499/detector-model/src/main/
java/branches/HPSJAVA-499/detector-model/src/main/java/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTestRunTracker2014Converter.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014Converter.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014ConverterBase.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014v1Converter.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/AlignmentCorrection.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/CompactSurveyVolume.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014GeometryDefinition.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014JavaBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014LCDDBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014GeometryDefinition.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014JavaBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014LCDDBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1GeometryDefinition.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1JavaBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1LCDDBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerGeometryDefinition.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerJavaBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerLCDDBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerJavaBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerLCDDBuilder.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaGhostSurveyVolume.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaSurveyVolume.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDGhostSurveyVolume.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDSurveyVolume.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/MilleParameter.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleComponentParameters.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleParameters.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyCoordinateSystem.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolume.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeImpl.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeVisualization.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SvtAlignmentConstantsReader.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014Base.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTestRunTracker2014.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014.java
java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014v1.java
java/branches/HPSJAVA-499/detector-model/src/test/
java/branches/HPSJAVA-499/detector-model/src/test/java/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/hps/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/hps/detector/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/hps/detector/SvtAlignmentTest.java
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014LCDDTest.java
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014LCDDTest.java
java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1LCDDTest.java
Added: java/branches/HPSJAVA-499/detector-model/pom.xml
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/pom.xml (added)
+++ java/branches/HPSJAVA-499/detector-model/pom.xml Tue May 5 14:05:24 2015
@@ -0,0 +1,59 @@
+<?xml version="1.0"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <artifactId>hps-detector-model</artifactId>
+ <name>detector-model</name>
+ <description>detector modeling code based on lcsim framework</description>
+ <parent>
+ <groupId>org.hps</groupId>
+ <artifactId>hps-parent</artifactId>
+ <relativePath>../parent/pom.xml</relativePath>
+ <version>3.3.1-SNAPSHOT</version>
+ </parent>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-shade-plugin</artifactId>
+ <executions>
+ <execution>
+ <phase>package</phase>
+ <goals>
+ <goal>shade</goal>
+ </goals>
+ <configuration>
+ <shadedArtifactAttached>true</shadedArtifactAttached>
+ <shadedClassifierName>bin</shadedClassifierName>
+ <transformers>
+ <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
+ <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <mainClass>org.lcsim.geometry.compact.converter.Main</mainClass>
+ </transformer>
+ </transformers>
+ <artifactSet>
+ <excludes>
+ <exclude>hep.testdata.aida:*</exclude>
+ </excludes>
+ </artifactSet>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ <scm>
+ <url>http://java.freehep.org/svn/repos/hps/list/java/trunk/detector-model/</url>
+ <connection>scm:svn:svn://svn.freehep.org/hps/java/trunk/detector-model/</connection>
+ <developerConnection>scm:svn:svn://svn.freehep.org/hps/java/trunk/detector-model/</developerConnection>
+ </scm>
+ <dependencies>
+ <dependency>
+ <groupId>org.hps</groupId>
+ <artifactId>hps-conditions</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.hps</groupId>
+ <artifactId>hps-detector-data</artifactId>
+ </dependency>
+ </dependencies>
+</project>
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTestRunTracker2014Converter.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTestRunTracker2014Converter.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTestRunTracker2014Converter.java Tue May 5 14:05:24 2015
@@ -0,0 +1,57 @@
+/**
+ *
+ */
+package org.lcsim.detector.converter.compact;
+
+import org.jdom.Element;
+import org.lcsim.detector.IDetectorElement;
+import org.lcsim.detector.identifier.IIdentifier;
+import org.lcsim.detector.tracker.silicon.HpsSiSensor;
+import org.lcsim.detector.tracker.silicon.HpsTestRunSiSensor;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014JavaBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerJavaBuilder;
+import org.lcsim.geometry.compact.converter.JavaSurveyVolume;
+import org.lcsim.geometry.subdetector.HPSTestRunTracker2014;
+
+/**
+ * Converts the HPSTestRunTracker2014 compact description into Java runtime objects
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTestRunTracker2014Converter extends HPSTracker2014ConverterBase {
+
+ public HPSTestRunTracker2014Converter() {
+ super();
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#initializeBuilder(org.jdom.Element)
+ */
+ protected HPSTrackerJavaBuilder initializeBuilder(Element node) {
+ return new HPSTestRunTracker2014JavaBuilder(_debug,node);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.AbstractSubdetectorConverter#getSubdetectorType()
+ */
+ public Class getSubdetectorType() {
+ return HPSTestRunTracker2014.class;
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#createSiSensor(int, java.lang.String, org.lcsim.detector.IDetectorElement, java.lang.String, org.lcsim.detector.identifier.IIdentifier)
+ */
+ HpsSiSensor createSiSensor(int sensorid, String name,
+ IDetectorElement parent, String support, IIdentifier id) {
+ return new HpsTestRunSiSensor(sensorid, name, parent, support, id);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#getModuleNumber(org.lcsim.geometry.compact.converter.JavaSurveyVolume)
+ */
+ protected int getModuleNumber(String surveyVolume) {
+ return HPSTrackerBuilder.getHalfFromName(surveyVolume).equals("top") ? 0 : 1;
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014Converter.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014Converter.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014Converter.java Tue May 5 14:05:24 2015
@@ -0,0 +1,88 @@
+package org.lcsim.detector.converter.compact;
+
+import org.jdom.Element;
+import org.lcsim.detector.IDetectorElement;
+import org.lcsim.detector.identifier.IIdentifier;
+import org.lcsim.detector.tracker.silicon.HpsSiSensor;
+import org.lcsim.geometry.compact.converter.HPSTracker2014JavaBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerJavaBuilder;
+import org.lcsim.geometry.compact.converter.JavaSurveyVolume;
+import org.lcsim.geometry.subdetector.HPSTracker2014;
+
+
+/**
+ * Converts the HPSTracker2014 compact description into Java runtime objects
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTracker2014Converter extends HPSTracker2014ConverterBase {
+
+ public HPSTracker2014Converter() {
+ super();
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#initializeBuilder(org.jdom.Element)
+ */
+ protected HPSTrackerJavaBuilder initializeBuilder(Element node) {
+ return new HPSTracker2014JavaBuilder(_debug, node);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.AbstractSubdetectorConverter#getSubdetectorType()
+ */
+ public Class getSubdetectorType() {
+ return HPSTracker2014.class;
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#createSiSensor(int, java.lang.String, org.lcsim.detector.IDetectorElement, java.lang.String, org.lcsim.detector.identifier.IIdentifier)
+ */
+ HpsSiSensor createSiSensor(int sensorid, String name,
+ IDetectorElement parent, String support, IIdentifier id) {
+ return new HpsSiSensor(sensorid, name, parent, support, id);
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#getModuleNumber(org.lcsim.geometry.compact.converter.JavaSurveyVolume)
+ */
+ protected int getModuleNumber(String surveyVolume) {
+ boolean isTopLayer = HPSTrackerBuilder.getHalfFromName(surveyVolume).equals("top") ? true : false;
+ int layer = HPSTrackerBuilder.getLayerFromVolumeName(surveyVolume);
+ int moduleNumber = -1;
+ if(isTopLayer) {
+ if(layer < 4 ) {
+ moduleNumber = 0;
+ } else {
+ if(HPSTrackerBuilder.isHoleFromName(surveyVolume)) {
+ moduleNumber = 0;
+ } else {
+ moduleNumber = 2;
+ }
+ }
+ } else {
+ if(layer < 4 ) {
+ moduleNumber = 1;
+ } else {
+ if(HPSTrackerBuilder.isHoleFromName(surveyVolume)) {
+ moduleNumber = 1;
+ } else {
+ moduleNumber = 3;
+ }
+ }
+ }
+
+ if(moduleNumber<0) throw new RuntimeException("Invalid module nr found for " + surveyVolume);
+
+ return moduleNumber;
+ }
+
+
+
+
+
+}
+
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014ConverterBase.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014ConverterBase.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014ConverterBase.java Tue May 5 14:05:24 2015
@@ -0,0 +1,535 @@
+package org.lcsim.detector.converter.compact;
+
+import org.jdom.Element;
+import org.lcsim.detector.DetectorElement;
+import org.lcsim.detector.DetectorElementStore;
+import org.lcsim.detector.DetectorIdentifierHelper;
+import org.lcsim.detector.DetectorIdentifierHelper.SystemMap;
+import org.lcsim.detector.IDetectorElement;
+import org.lcsim.detector.IGeometryInfo;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.detector.IPhysicalVolume;
+import org.lcsim.detector.PhysicalVolume;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.detector.converter.compact.subdetector.HpsTracker2;
+import org.lcsim.detector.identifier.ExpandedIdentifier;
+import org.lcsim.detector.identifier.IExpandedIdentifier;
+import org.lcsim.detector.identifier.IIdentifier;
+import org.lcsim.detector.identifier.IIdentifierDictionary;
+import org.lcsim.detector.identifier.IIdentifierHelper;
+import org.lcsim.detector.material.IMaterial;
+import org.lcsim.detector.material.MaterialStore;
+import org.lcsim.detector.tracker.silicon.HpsSiSensor;
+import org.lcsim.detector.tracker.silicon.SiTrackerIdentifierHelper;
+import org.lcsim.detector.tracker.silicon.SiTrackerModule;
+import org.lcsim.geometry.compact.Detector;
+import org.lcsim.geometry.compact.Subdetector;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerJavaBuilder;
+import org.lcsim.geometry.compact.converter.JavaGhostSurveyVolume;
+import org.lcsim.geometry.compact.converter.JavaSurveyVolume;
+
+/**
+ * Converts the compact description into Java runtime objects
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public abstract class HPSTracker2014ConverterBase extends AbstractSubdetectorConverter {
+
+ protected boolean _debug = false;
+ protected IMaterial trackingMaterial = null;
+ protected static HPSTrackerJavaBuilder builder;
+
+ /**
+ * Default constructor.
+ */
+ public HPSTracker2014ConverterBase() {
+ super();
+ }
+
+ /**
+ * Initialize builder for this converter.
+ * @param node
+ * @return builder.
+ */
+ abstract protected HPSTrackerJavaBuilder initializeBuilder(Element node);
+
+
+ /**
+ * Abstract method to create the correct type of {@link HpsSiSensor}.
+ * @param sensorid
+ * @param name
+ * @param parent
+ * @param support
+ * @param id
+ * @return the created sensor.
+ */
+ abstract HpsSiSensor createSiSensor(int sensorid, String name, IDetectorElement parent, String support, IIdentifier id);
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.AbstractSubdetectorConverter#makeIdentifierHelper(org.lcsim.geometry.compact.Subdetector, org.lcsim.detector.DetectorIdentifierHelper.SystemMap)
+ */
+ public IIdentifierHelper makeIdentifierHelper(Subdetector subdetector, SystemMap systemMap) {
+ return new SiTrackerIdentifierHelper(subdetector.getDetectorElement(), makeIdentifierDictionary(subdetector), systemMap);
+ }
+
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.AbstractSubdetectorConverter#convert(org.lcsim.geometry.compact.Subdetector, org.lcsim.geometry.compact.Detector)
+ */
+ public void convert(Subdetector subdet, Detector detector) {
+
+ if(_debug) System.out.printf("%s: convert %s \n", getClass().getSimpleName(), subdet.getName());
+
+
+ // check tracking material
+ trackingMaterial = MaterialStore.getInstance().get("Vacuum");
+ if(trackingMaterial==null) {
+ throw new RuntimeException("error the tracking material was not found!");
+ }
+
+ // Get XML node for this subdetector.
+ Element node = subdet.getNode();
+
+ // Get the tracking volume for module placement.
+ ILogicalVolume trackingVolume = detector.getTrackingVolume().getLogicalVolume();
+
+
+
+ // build the local geometry
+ builder = initializeBuilder(node);
+ //builder = new HPSTestRunTracker2014JavaBuilder(_debug,node);
+
+
+ // Set subdetector for later reference
+ builder.setSubdetector(subdet);
+
+ // Get ID helper and dictionary for subdetector.
+ builder.setDetectorIdentifierHelper( (DetectorIdentifierHelper) subdet.getDetectorElement().getIdentifierHelper());
+ builder.setIdentifierDictionary(subdet.getDetectorElement().getIdentifierHelper().getIdentifierDictionary());
+
+
+
+ // Build the detector here
+ // setup and build the LCDD geometry
+ if(_debug) System.out.printf("%s: setup and build the JAVA geometry\n", getClass().getSimpleName());
+
+ builder.build(trackingVolume);
+
+ if(_debug) System.out.printf("%s: DONE setup and build the JAVA geometry\n", getClass().getSimpleName());
+
+ if(_debug) System.out.printf("%s: setup physical volumes\n", getClass().getSimpleName());
+
+ setupPhysicalVolumes();
+
+ if(_debug) System.out.printf("%s: DONE setup physical volumes\n", getClass().getSimpleName());
+
+ if(_debug) System.out.printf("%s: create stereo layers\n", getClass().getSimpleName());
+
+ ((HpsTracker2) subdet.getDetectorElement()).createStereoLayers();
+
+ if(_debug) System.out.printf("%s: DONE create stereo layers\n", getClass().getSimpleName());
+
+ if(_debug) printDEs();
+
+ }
+
+
+
+
+ /**
+ * Setup physical volumes based on the top level {@link JavaSurveyVolume}.
+ */
+ private void setupPhysicalVolumes() {
+
+ if(_debug) System.out.printf("%s: setup the detector elements\n", getClass().getSimpleName());
+
+ setupPhysicalVolumes(builder.getBaseTrackerGeometry());
+
+ if(_debug) System.out.printf("%s: DONE setup the detector elements\n", getClass().getSimpleName());
+
+ }
+
+
+ /**
+ * Setup the physical volumes recursively
+ * @param surveyVolume - volume to process.
+ */
+ private void setupPhysicalVolumes(JavaSurveyVolume surveyVolume) {
+
+ if(_debug) System.out.printf("%s: setupDetectorElement for %s\n", getClass().getSimpleName(),surveyVolume.getName());
+
+ // Only certain objects are setup as detector elements
+ // Ghost volumes are never setup
+
+ // I do this recursively for daughters now as I wanted it to be generic
+ // but for now since I know what the daughters are I could manually
+ // go and add:layer->module->sensor detector elements similar to
+ // the old setup. I wanted this to be more generic in case more structures
+ // are added so I keep track of all the elements in the builder in order
+ // to build a hierarchy.
+
+ if( surveyVolume instanceof JavaGhostSurveyVolume) {
+
+ if(_debug) System.out.printf("%s: %s is a ghost volume, dont create elements or physvol\n", getClass().getSimpleName(),surveyVolume.getName());
+
+ } else if(surveyVolume.getName().contains("tracking")) {
+ if(_debug) System.out.printf("%s: %s is the tracking volume, dont create elements or physvol\n", getClass().getSimpleName(),surveyVolume.getName());
+ } else {
+
+ // build the physical volume
+ surveyVolume.buildPhysVolume();
+
+ // create detector element
+ // create detector element
+ if(HPSTrackerBuilder.isBase(surveyVolume.getName())) {
+
+ if(_debug) System.out.printf("%s: create the base detector element\n", getClass().getSimpleName());
+
+ createBaseDetectorElement(surveyVolume);
+
+ if(_debug) System.out.printf("%s: DONE create the base detector element\n", getClass().getSimpleName());
+
+
+ } else if(HPSTrackerBuilder.isHalfModule(surveyVolume.getName())) {
+
+ if(_debug) System.out.printf("%s: create the layer detector element\n", getClass().getSimpleName());
+
+ IDetectorElement layerDe = createLayerDetectorElement(surveyVolume);
+
+ if(_debug) System.out.printf("%s: DONE create the layer detector element\n", getClass().getSimpleName());
+
+ if(_debug) System.out.printf("%s: create the module detector element\n", getClass().getSimpleName());
+
+ createTrackerModuleDetectorElement(surveyVolume, layerDe);
+
+ if(_debug) System.out.printf("%s: DONE create the module detector element\n", getClass().getSimpleName());
+
+
+ } else if(HPSTrackerBuilder.isSensor(surveyVolume.getName())) {
+
+ if(_debug) System.out.printf("%s: set sensitive volume for sensor %s\n", getClass().getSimpleName(),surveyVolume.getName());
+
+ createSensorDetectorElement(surveyVolume);
+
+ if(_debug) System.out.printf("%s: DONE set sensitive volume for sensor %s\n", getClass().getSimpleName(),surveyVolume.getName());
+
+
+ } else if(HPSTrackerBuilder.isActiveSensor(surveyVolume.getName())) {
+
+ if(_debug) System.out.printf("%s: create the active sensor detector element\n", getClass().getSimpleName());
+
+ createActiveSensorDetectorElement(surveyVolume);
+
+ if(_debug) System.out.printf("%s: DONE create the active sensor detector element\n", getClass().getSimpleName());
+
+ } else {
+ throw new RuntimeException("I don't think I should reach this? Should " + surveyVolume.getName() + " be a ghost?" );
+ }
+
+ }
+
+ // add daughters
+ if(_debug) System.out.printf("%s: add %d daughters to %s\n", this.getClass().getSimpleName(),surveyVolume.getDaughters().size(), surveyVolume.getName());
+ for(JavaSurveyVolume daughter : surveyVolume.getDaughters()) {
+ setupPhysicalVolumes(daughter);
+ }
+
+ if(_debug) System.out.printf("%s: DONE setup the detector element for %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+
+ }
+
+
+
+
+ /**
+ * Find the module {@link DetectorElement} in a layer {@link DetectorElement} using the module number id.
+ * @param layerDe
+ * @param moduleNumber
+ * @return the found {@link DetectorElement} or {@code null} if not found.
+ */
+ private IDetectorElement getModuleDetectorElement(IDetectorElement layerDe, int moduleNumber) {
+ //Find the module by looping over the modules and checking module number
+ IDetectorElement moduleDe = null;
+ for(IDetectorElement e : layerDe.getChildren()) {
+ if(e instanceof SiTrackerModule) {
+ SiTrackerModule m = (SiTrackerModule)e;
+ if(m.getModuleId()==moduleNumber) {
+ moduleDe = m;
+ }
+ }
+ }
+ return moduleDe;
+ }
+
+ /**
+ * Abstract method to find the module number.
+ * @param surveyVolume
+ * @return module number
+ */
+ abstract protected int getModuleNumber(String surveyVolume);
+
+ /**
+ * Find the layer {@link DetectorElement}.
+ * @param surveyVolume
+ * @return the {@link DetectorElement}.
+ */
+ private IDetectorElement getLayerDetectorElement(JavaSurveyVolume surveyVolume) {
+ // Helper
+ IIdentifierDictionary iddict = builder.getDetectorIdentifierHelper().getIdentifierDictionary();
+
+ // Find the mother: the module detector element
+ IExpandedIdentifier layerExpId = new ExpandedIdentifier(iddict.getNumberOfFields());
+ layerExpId.setValue(iddict.getFieldIndex("system"), builder.getSubdetector().getSystemID());
+ layerExpId.setValue(iddict.getFieldIndex("barrel"), builder.getDetectorIdentifierHelper().getBarrelValue());
+ //use the old definition of layer number to be consistent
+ //int layer = HPSTestRunTracker2014Builder.getLayerFromVolumeName(geometryObject.getName());
+ int layer = builder._builder.getOldGeomDefLayerFromVolumeName(surveyVolume.getName());
+ layerExpId.setValue(iddict.getFieldIndex("layer"), layer);
+ //Find the layer from the ID
+ return builder.getLayerDetectorElement(layerExpId);
+ }
+
+
+
+ /**
+ * Create the {@link HpsSiSensor} detector element.
+ * @param surveyVolume
+ */
+ private void createActiveSensorDetectorElement(JavaSurveyVolume surveyVolume) {
+ // Setup the active sensor element
+ // to be consistent with old converter I also add the sensor
+ // in the path to the element even though it's not associated with
+ // with a element. I'm not sure why this is done.
+
+
+ if(_debug) System.out.printf("%s: find the active sensor phys vol\n", this.getClass().getSimpleName());
+
+ // Find active Sensor physical volume.
+ // Keep name consistent with old converter
+ PhysicalVolume sensorPhysVol = (PhysicalVolume) surveyVolume.getPhysVolume();
+
+ if(sensorPhysVol==null) throw new RuntimeException("cannot find physVol for " + surveyVolume.getName());
+
+ if(_debug) System.out.printf("%s: found %s phys vol\n", this.getClass().getSimpleName(),sensorPhysVol.getName());
+
+ // find the layer and module detector element
+
+ IDetectorElement layerDe = getLayerDetectorElement(surveyVolume);
+
+ if(layerDe==null) throw new RuntimeException("Cannot find layer DE");
+
+ //Find the module number
+ int moduleNumber = getModuleNumber(surveyVolume.getName());
+
+ //Find the module detector element
+ IDetectorElement moduleDe = getModuleDetectorElement(layerDe, moduleNumber);
+
+ if(moduleDe==null) throw new RuntimeException("Cannot find module DE for " + surveyVolume.getName());
+
+ // Setup SiSensor's identifier.
+ IIdentifierDictionary iddict = builder.getIdentifierDictionary();
+ IExpandedIdentifier expId = new ExpandedIdentifier(iddict.getNumberOfFields());
+ expId.setValue(iddict.getFieldIndex("system"), builder.getSubdetector().getSystemID());
+ expId.setValue(iddict.getFieldIndex("barrel"), 0);
+ expId.setValue(iddict.getFieldIndex("layer"), builder.getDetectorIdentifierHelper().getValue(layerDe.getIdentifier(), "layer"));
+ expId.setValue(iddict.getFieldIndex("module"), ((SiTrackerModule) moduleDe).getModuleId());
+ // The sensorNumber is always 0 in the old geometry. Keep it that way.
+ int sensorNumber = 0;
+ expId.setValue(iddict.getFieldIndex("sensor"), sensorNumber);
+
+
+ // Packed identifier.
+ IIdentifier sensorId = iddict.pack(expId);
+
+ // Sensor paths.
+ String modulePath = moduleDe.getGeometry().getPathString();
+ IPhysicalVolume componentPhysVol = surveyVolume.getPhysMother().getPhysVolume();
+ String sensorPath = modulePath.toString() + "/" + componentPhysVol.getName() + "/" + sensorPhysVol.getName();
+ String sensorName = moduleDe.getName() + "_sensor" + sensorNumber;
+
+ if(_debug) {
+ System.out.printf("%s: create HpsSiSensor with old layer id %d with sensorNumber %d name %s moduleDe %s sensorPath %s sensor Id %d \n", getClass().getSimpleName(),
+ layerDe.getIdentifier(),sensorNumber, sensorName, moduleDe.getName(), sensorPath, sensorNumber);
+ }
+ System.out.printf("%s: HpsSiSensor old layer id %d and module nr %d and sensor nr %d <-> DE name %s \n", getClass().getSimpleName(),
+ builder.getDetectorIdentifierHelper().getValue(layerDe.getIdentifier(), "layer"), ((SiTrackerModule) moduleDe).getModuleId(), sensorNumber,sensorName);
+
+ // Create the sensor.
+ int millepedeLayer = builder._builder.getMillepedeLayer(sensorName);
+ HpsSiSensor sensor = createSiSensor(sensorNumber, sensorName, moduleDe, sensorPath, sensorId);
+ sensor.setMillepedeId(millepedeLayer);
+ //if(_debug) System.out.printf("%s: created sensor %s with id %d and expId %s \n", getClass().getSimpleName(), sensor.getName(), sensor.getIdentifier().getValue(), sensor.getExpandedIdentifier().toString());
+ if(_debug) System.out.printf("%s: created sensor %s with layer %d and MP layer %d\n", getClass().getSimpleName(), sensor.getName(), sensor.getLayerNumber(),sensor.getMillepedeId());
+
+
+ }
+
+
+
+ /**
+ * Set the sensor {@link PhysicalVolume} to be sensitive.
+ * @param surveyVolume
+ */
+ private void createSensorDetectorElement(JavaSurveyVolume surveyVolume) {
+
+ // set the physical volume to be sensitive
+ // TODO this should go into the geometry definition?!
+ ((PhysicalVolume)surveyVolume.getPhysVolume()).setSensitive(true);
+
+ }
+
+ /**
+ * Create the {@link SiTrackerModule}.
+ * @param surveyVolume
+ * @param layerDe - mother {@link DetectorElement}
+ */
+ protected void createTrackerModuleDetectorElement(JavaSurveyVolume surveyVolume, IDetectorElement layerDe) {
+ // create the "module" detector element
+ // it's under the base element
+
+ int moduleNumber = getModuleNumber(surveyVolume.getName());
+
+ String modulePlacementName = surveyVolume.getName();// builder.getSubdetector().getName() + "_" + moduleName + "_layer" + layer + "_module" + moduleNumber;
+
+ // find the base DE as mother
+ IDetectorElement baseDe = builder.getBaseDetectorElement();
+ if(baseDe==null) {
+ throw new RuntimeException("Base DE couldn't be found. Shouldn't happen!");
+ }
+
+ // use base as mother for physical volume
+ String modulePath = baseDe.getGeometry().getPathString() + "/" + modulePlacementName;
+
+ if(_debug) {
+ System.out.printf("%s: create SiTrackerModule with: placementname %s, modulePath %s, moduleNumber %d \n", getClass().getSimpleName(),modulePlacementName, modulePath, moduleNumber);
+ }
+
+ SiTrackerModule moduleDe = new SiTrackerModule(modulePlacementName, layerDe, modulePath, moduleNumber);
+
+ if(_debug) System.out.printf("%s: add module DE to existing ones \n", getClass().getSimpleName(),modulePlacementName, modulePath, moduleNumber);
+
+
+ //keep track of the module detector element
+ builder.addModuleDetectorElement(moduleDe);
+
+ }
+
+
+
+
+ /**
+ * Create the layer {@link DetectorElement}
+ * @param surveyVolume
+ * @return the detector element.
+ */
+ protected IDetectorElement createLayerDetectorElement(JavaSurveyVolume surveyVolume) {
+ int nfields = builder.getDetectorIdentifierHelper().getIdentifierDictionary().getNumberOfFields();
+ IExpandedIdentifier layerPosId = new ExpandedIdentifier(nfields);
+ layerPosId.setValue(builder.getDetectorIdentifierHelper().getFieldIndex("system"), builder.getSubdetector().getSystemID());
+ layerPosId.setValue(builder.getDetectorIdentifierHelper().getFieldIndex("barrel"), builder.getDetectorIdentifierHelper().getBarrelValue());
+ //use the old definition of layer number to be consistent
+ //int layer = HPSTestRunTracker2014Builder.getLayerFromVolumeName(geometryObject.getName());
+ int layer = builder._builder.getOldGeomDefLayerFromVolumeName(surveyVolume.getName());
+ layerPosId.setValue(builder.getDetectorIdentifierHelper().getFieldIndex("layer"), layer);
+ if(_debug) System.out.printf("%s: layerPosId layer = %d (compare with new layer %d)\n", getClass().getSimpleName(),layer, HPSTrackerBuilder.getLayerFromVolumeName(surveyVolume.getName()));
+
+ // find the base DE as mother
+ IDetectorElement baseDe = builder.getBaseDetectorElement();
+ if(baseDe==null) {
+ throw new RuntimeException("Base DE couldn't be found. Shouldn't happen!");
+ }
+
+
+ // create the layer detector element and keep track of it
+ //IDetectorElement layerDe = builder.getLayerDetectorElement(layerPosId);
+ IDetectorElement layerDe = builder.getLayerDetectorElement(layerPosId);
+
+ if(layerDe==null) {
+ //layerDe = new DetectorElement(builder.getSubdetector().getName() + "_layer" + layer, builder.getSubdetector().getDetectorElement(), builder.getDetectorIdentifierHelper().pack(layerPosId));
+ layerDe = new DetectorElement(builder.getSubdetector().getName() + "_layer" + layer, baseDe, builder.getDetectorIdentifierHelper().pack(layerPosId));
+ builder.addLayerDetectorElement(layerDe);
+ } else {
+ if(_debug) System.out.printf("%s: layerDE exists\n", getClass().getSimpleName());
+ }
+
+ if(_debug) System.out.printf("%s: created layerDE %s \n", getClass().getSimpleName(),layerDe.getName());
+
+ return layerDe;
+ }
+
+
+
+ /**
+ * Create the tracker base {@link DetectorElement}
+ * @param surveyVolume
+ */
+ void createBaseDetectorElement(JavaSurveyVolume surveyVolume) {
+
+ int nfields = builder.getDetectorIdentifierHelper().getIdentifierDictionary().getNumberOfFields();
+ IExpandedIdentifier layerPosId = new ExpandedIdentifier(nfields);
+ layerPosId.setValue(builder.getDetectorIdentifierHelper().getFieldIndex("system"), builder.getSubdetector().getSystemID());
+ layerPosId.setValue(builder.getDetectorIdentifierHelper().getFieldIndex("barrel"), builder.getDetectorIdentifierHelper().getBarrelValue());
+ int layer = 22; // dummy value
+ layerPosId.setValue(builder.getDetectorIdentifierHelper().getFieldIndex("layer"), layer);
+ IDetectorElement baseDe = builder.getBaseDetectorElement();
+ if(baseDe!=null) {
+ throw new RuntimeException("Base exists. Shouldn't happen!");
+ }
+ ILogicalVolume trackingVolume = surveyVolume.getPhysMother().getVolume();
+ if(!trackingVolume.getName().contains("tracking")) {
+ throw new RuntimeException("base phys mother " + surveyVolume.getPhysMother().getName() + " is not tracking volume!?");
+ }
+ String physVolPath = trackingVolume.getName() + "/" + surveyVolume.getPhysVolume().getName();
+ baseDe = new DetectorElement(builder.getSubdetector().getName() + "_base", builder.getSubdetector().getDetectorElement(), physVolPath, builder.getIdentifierDictionary().pack(layerPosId));
+ builder.addBaseDetectorElement(baseDe);
+
+ if(_debug) System.out.printf("%s: baseDE name %s \n", getClass().getSimpleName(),baseDe.getName());
+ }
+
+
+ public IDetectorElement makeSubdetectorDetectorElement(Detector detector, Subdetector subdetector) {
+
+ if(_debug) System.out.printf("%s: makeSubdetectorDetectorElement for subdetector %s\n", getClass().getSimpleName(),subdetector.getName());
+
+ IDetectorElement subdetectorDE =
+ new HpsTracker2(subdetector.getName(), detector.getDetectorElement());
+ subdetector.setDetectorElement(subdetectorDE);
+ return subdetectorDE;
+ }
+
+ private void printDEs() {
+ System.out.printf("%s: Print all %d detector elements in store\n", getClass().getSimpleName(),DetectorElementStore.getInstance().size());
+ for(IDetectorElement e : DetectorElementStore.getInstance()) {
+ System.out.printf("%s: Name: %s \n", getClass().getSimpleName(),e.getName());
+ /*
+ if(e.getIdentifier()==null) {
+ System.out.printf("%s: no id found\n", getClass().getSimpleName());
+ } else {
+ if(e.getExpandedIdentifier()==null)
+ System.out.printf("%s: no exp id found\n", getClass().getSimpleName());
+ else
+ System.out.printf("%s: %s \n", getClass().getSimpleName(),e.getExpandedIdentifier().toString());
+ }
+ */
+ if(e.hasGeometryInfo()) {
+ System.out.printf("%s: Position: %s \n", getClass().getSimpleName(),e.getGeometry().getPosition());
+ System.out.printf("%s: LocalToGlobal: \n%s \n", getClass().getSimpleName(),((Transform3D)e.getGeometry().getLocalToGlobal()).toString());
+ //System.out.printf("%s: GlobalToLocal: \n%s \n", getClass().getSimpleName(),((Transform3D)e.getGeometry().getGlobalToLocal()).toString());
+ IGeometryInfo info = e.getGeometry();
+ if(info!=null) {
+ while((info=info.parentGeometry())!=null) {
+ System.out.printf("%s: Parent geometry DE: %s \n", getClass().getSimpleName(),info.getDetectorElement().getName());
+ System.out.printf("%s: Parent Position: %s \n", getClass().getSimpleName(),info.getPosition());
+ System.out.printf("%s: Parent LocalToGlobal: \n%s \n", getClass().getSimpleName(),((Transform3D)info.getLocalToGlobal()).toString());
+
+ }
+ }
+ }
+ }
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014v1Converter.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014v1Converter.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/detector/converter/compact/HPSTracker2014v1Converter.java Tue May 5 14:05:24 2015
@@ -0,0 +1,29 @@
+package org.lcsim.detector.converter.compact;
+
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.HPSTracker2014v1JavaBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerJavaBuilder;
+import org.lcsim.geometry.subdetector.HPSTracker2014v1;
+
+public class HPSTracker2014v1Converter extends HPSTracker2014Converter {
+
+ public HPSTracker2014v1Converter() {
+ super();
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#initializeBuilder(org.jdom.Element)
+ */
+ protected HPSTrackerJavaBuilder initializeBuilder(Element node) {
+ return new HPSTracker2014v1JavaBuilder(_debug, node);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.AbstractSubdetectorConverter#getSubdetectorType()
+ */
+ public Class getSubdetectorType() {
+ return HPSTracker2014v1.class;
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/AlignmentCorrection.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/AlignmentCorrection.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/AlignmentCorrection.java Tue May 5 14:05:24 2015
@@ -0,0 +1,48 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+
+/**
+ * Class containing the final translation and rotation correction from alignment.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class AlignmentCorrection {
+ private Rotation rotation = null;
+ private Hep3Vector translation = null;
+ public AlignmentCorrection(double x, double y, double z, double rot_x, double rot_y, double rot_z) {
+ setTranslation(x, y, z);
+ setRotation(rot_x, rot_y, rot_z);
+ }
+ public AlignmentCorrection() {
+ }
+ public Rotation getRotation() {
+ return rotation;
+ }
+ public void setRotation(Rotation rotation) {
+ this.rotation = rotation;
+ }
+ public void setRotation(double rot_x, double rot_y, double rot_z) {
+ Rotation rx = new Rotation(new Vector3D(1,0,0),rot_x);
+ Rotation ry = new Rotation(new Vector3D(0,1,0),rot_y);
+ Rotation rz = new Rotation(new Vector3D(0,0,1),rot_z);
+ // Build full rotation
+ Rotation rzyx = rz.applyTo(ry.applyTo(rx));
+ setRotation(rzyx);
+ }
+ public Hep3Vector getTranslation() {
+ return translation;
+ }
+ public void setTranslation(Hep3Vector translation) {
+ this.translation = translation;
+ }
+ public void setTranslation(double x, double y, double z) {
+ setTranslation(new BasicHep3Vector(x,y,z));
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/CompactSurveyVolume.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/CompactSurveyVolume.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/CompactSurveyVolume.java Tue May 5 14:05:24 2015
@@ -0,0 +1,223 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import java.util.List;
+
+import org.jdom.DataConversionException;
+import org.jdom.Element;
+
+public abstract class CompactSurveyVolume extends SurveyVolume {
+ public static final String xmlTagNameTop = "SurveyVolumes";
+ public static final String xmlTagName = "SurveyVolume";
+
+ Element node = null;
+
+ public CompactSurveyVolume(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, Element node2) {
+ super(name, m, alignmentCorrection);
+ node = node2;
+ }
+
+ public CompactSurveyVolume(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref, Element node2) {
+ super(name, m, alignmentCorrection, ref);
+ node = node2;
+ }
+
+
+ /**
+ * Extract survey positions from xml description
+ */
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: getSurveyPosFromCompact for %s from %s\n",getClass().getSimpleName(), getName(), node.getAttributeValue("name"));
+
+ Element eNameTop = node.getChild(xmlTagNameTop);
+ if(eNameTop==null) {
+ throw new RuntimeException("no eName for " + xmlTagNameTop + " found in compact file");
+ }
+
+ List<Element> eNames = eNameTop.getChildren(xmlTagName);
+ if(eNames==null) {
+ throw new RuntimeException("no eNames for " + xmlTagName + " found in compact file");
+ }
+
+ for(Element eName : eNames) {
+
+ if(eName.getAttributeValue("name").compareTo(getName())==0) {
+
+
+ Element eCoord = eName.getChild("SurveyPos");
+
+ if(eCoord==null) {
+ throw new RuntimeException("no eCoord for " + getName() + " found in compact file");
+ }
+
+// Element eOrigin = eCoord.getChild("origin");
+//
+// if(eOrigin==null) {
+// throw new RuntimeException("no eOrigin for " + getName() + " found in compact file");
+// }
+
+// origin = null;
+// try {
+// double x,y,z;
+// x= eOrigin.getAttribute("x").getDoubleValue();
+// y= eOrigin.getAttribute("y").getDoubleValue();
+// z= eOrigin.getAttribute("z").getDoubleValue();
+// origin = new BasicHep3Vector(x, y, z);
+// } catch (DataConversionException e) {
+// e.printStackTrace();
+// }
+
+ List<Element> eCoordComponents = eCoord.getChildren("point");
+
+ for(Element eUnitVec: eCoordComponents) {
+ try {
+ double x,y,z;
+ if(eUnitVec.getAttributeValue("name").compareTo("ball") == 0) {
+ x = eUnitVec.getAttribute("x").getDoubleValue();
+ y = eUnitVec.getAttribute("y").getDoubleValue();
+ z = eUnitVec.getAttribute("z").getDoubleValue();
+ setBallPos(x, y, z);
+ } else if(eUnitVec.getAttributeValue("name").compareTo("vee") == 0) {
+ x = eUnitVec.getAttribute("x").getDoubleValue();
+ y = eUnitVec.getAttribute("y").getDoubleValue();
+ z = eUnitVec.getAttribute("z").getDoubleValue();
+ setVeePos(x, y, z);
+ } else if(eUnitVec.getAttributeValue("name").compareTo("flat") == 0) {
+ x = eUnitVec.getAttribute("x").getDoubleValue();
+ y = eUnitVec.getAttribute("y").getDoubleValue();
+ z = eUnitVec.getAttribute("z").getDoubleValue();
+ setFlatPos(x, y, z);
+ } else {
+ throw new RuntimeException("eUnitVec name " + eUnitVec.getAttributeValue("name") + " is ill-defined for " + getName() + " found in compact file");
+ }
+ } catch (DataConversionException e) {
+ e.printStackTrace();
+ }
+ }
+
+
+
+
+ }
+ }
+ if(debug) {
+ System.out.printf("%s: Extracted these survey constants from compact\n", this.getClass().getSimpleName());
+ System.out.printf("%s: ball %s \n", this.getClass().getSimpleName(),getBallPos().toString());
+ System.out.printf("%s: vee %s \n", this.getClass().getSimpleName(),getVeePos().toString());
+ System.out.printf("%s: flat %s \n", this.getClass().getSimpleName(),getFlatPos().toString());
+ }
+
+ }
+
+
+
+ /**
+ * Extract coordinate system from xml description
+ */
+ private void getCoordFromCompact() {
+
+
+
+ if(debug) System.out.printf("%s: getCoordFromCompact for %s from %s\n",getClass().getSimpleName(), getName(), node.getAttributeValue("name"));
+
+ if(1==1)
+ throw new UnsupportedOperationException("Need to work on interface of a new coordinate system and the ball, vee, flat procedure to build coord system!");
+
+
+
+ Element eNameTop = node.getChild(xmlTagNameTop);
+ if(eNameTop==null) {
+ throw new RuntimeException("no eName for " + xmlTagNameTop + " found in compact file");
+ }
+
+ List<Element> eNames = eNameTop.getChildren(xmlTagName);
+ if(eNames==null) {
+ throw new RuntimeException("no eNames for " + xmlTagName + " found in compact file");
+ }
+
+ for(Element eName : eNames) {
+
+ if(eName.getAttributeValue("name").compareTo(getName())==0) {
+
+
+ Element eCoord = eName.getChild("SurveyCoord");
+
+ if(eCoord==null) {
+ throw new RuntimeException("no eCoord for " + getName() + " found in compact file");
+ }
+
+ Element eOrigin = eCoord.getChild("origin");
+
+ if(eOrigin==null) {
+ throw new RuntimeException("no eOrigin for " + getName() + " found in compact file");
+ }
+
+ Hep3Vector coord_org = null;
+ Hep3Vector coord_unit_u = null;
+ Hep3Vector coord_unit_v = null;
+ Hep3Vector coord_unit_w = null;
+
+
+ double x,y,z;
+ try {
+ x= eOrigin.getAttribute("x").getDoubleValue();
+ y= eOrigin.getAttribute("y").getDoubleValue();
+ z= eOrigin.getAttribute("z").getDoubleValue();
+ coord_org =new BasicHep3Vector(x, y, z);
+ } catch (DataConversionException e) {
+ e.printStackTrace();
+ }
+
+
+
+
+ List<Element> eCoordComponents = eCoord.getChildren("unitVec");
+
+ for(Element eUnitVec: eCoordComponents) {
+ try {
+ double ux,uy,uz;
+ double vx,vy,vz;
+ double wx,wy,wz;
+ if(eUnitVec.getAttributeValue("name").compareTo("u") == 0) {
+ ux = eUnitVec.getAttribute("x").getDoubleValue();
+ uy = eUnitVec.getAttribute("y").getDoubleValue();
+ uz = eUnitVec.getAttribute("z").getDoubleValue();
+ coord_unit_u = new BasicHep3Vector(ux, uy, uz);
+ } else if(eUnitVec.getAttributeValue("name").compareTo("v") == 0) {
+ vx = eUnitVec.getAttribute("x").getDoubleValue();
+ vy = eUnitVec.getAttribute("y").getDoubleValue();
+ vz = eUnitVec.getAttribute("z").getDoubleValue();
+ coord_unit_v = new BasicHep3Vector(vx, vy, vz);
+ } else if(eUnitVec.getAttributeValue("name").compareTo("w") == 0) {
+ wx = eUnitVec.getAttribute("x").getDoubleValue();
+ wy = eUnitVec.getAttribute("y").getDoubleValue();
+ wz = eUnitVec.getAttribute("z").getDoubleValue();
+ coord_unit_w = new BasicHep3Vector(wx, wy, wz);
+ } else {
+ throw new RuntimeException("eUnitVec name " + eUnitVec.getAttributeValue("name") + " is ill-defined for " + getName() + " found in compact file");
+ }
+ } catch (DataConversionException e) {
+ e.printStackTrace();
+ }
+ }
+
+ throw new RuntimeException("need to work on this!");
+ //SurveyCoordinateSystem coord = new SurveyCoordinateSystem(coord_org, coord_unit_u, coord_unit_v, coord_unit_w);
+ //setCoord(coord);
+
+ }
+ }
+ if(debug) {
+ System.out.printf("%s: found coord system\n%s\n", this.getClass().getSimpleName(),getCoord().toString());
+ }
+
+ }
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014GeometryDefinition.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014GeometryDefinition.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014GeometryDefinition.java Tue May 5 14:05:24 2015
@@ -0,0 +1,1841 @@
+/**
+ *
+ */
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+
+import java.util.List;
+
+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.RotationOrder;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import org.jdom.Element;
+
+/**
+ *
+ * Geometry information for the HPS Test run tracker
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTestRunTracker2014GeometryDefinition extends HPSTrackerGeometryDefinition {
+
+
+
+
+ //General
+ protected static final boolean useSiStripsConvention = true;
+ protected static final boolean use30mradRotation = true;
+ protected static final boolean useFakeHalfModuleAxialPos = false;
+
+ // Global position references
+ protected static final double target_pos_wrt_base_plate_x = 162.3; //from Marco's 3D model
+ protected static final double target_pos_wrt_base_plate_y = 80.55; //from Tim's sketchup //68.75; //from Marco's 3D model
+ protected static final double target_pos_wrt_base_plate_z = 926.59; //from Marco's 3D model
+
+
+
+ public HPSTestRunTracker2014GeometryDefinition(boolean debug, Element node) {
+ super(debug, node);
+ doAxial = true;
+ doStereo = true;
+ doColdBlock = false;
+ doBottom = true;
+ doTop = true;
+ layerBitMask = 0x1F; //0x1;//
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerBuilder#build()
+ */
+ public void build() {
+
+ if(isDebug()) System.out.printf("%s: constructing the geometry objects\n", this.getClass().getSimpleName());
+
+ // Build the geometry from the basic building blocks in the geometry definition class
+ // Keep the order correct.
+ // Each item has knowledge of its mother but not its daughters
+ TrackingVolume tracking = new TrackingVolume("trackingVolume",null);
+ surveyVolumes.add(tracking);
+
+ TrackerEnvelope base = new TrackerEnvelope("base",tracking);
+ surveyVolumes.add(base);
+
+ BasePlate basePlate = new BasePlate("baseplate",base, "Aluminum");
+ surveyVolumes.add(basePlate);
+
+ CSupport cSupport = new CSupport("c_support", base);
+ surveyVolumes.add(cSupport);
+
+ AlignmentCorrection alignmentCorrectionSupportBottom = getSupportAlignmentCorrection(false);
+ SupportBottom supportBottom = new SupportBottom("support_bottom", base, alignmentCorrectionSupportBottom, cSupport);
+ surveyVolumes.add(supportBottom);
+ // The support survey positions are now with respect to its mother and not the reference coord. system.
+ // So to get the reference for the support plate I don't need to apply that extra transformation
+
+ SupportPlateBottom supportPlateBottom = new SupportPlateBottom("support_plate_bottom", base, supportBottom, "Aluminum");
+ surveyVolumes.add(supportPlateBottom);
+
+ AlignmentCorrection alignmentCorrectionSupportTop = getSupportAlignmentCorrection(true);
+ SupportTop supportTop = new SupportTop("support_top", base, alignmentCorrectionSupportTop, cSupport);
+ surveyVolumes.add(supportTop);
+
+ SupportPlateTop supportPlateTop = new SupportPlateTop("support_plate_top", base, supportTop, "Aluminum");
+ surveyVolumes.add(supportPlateTop);
+
+ for(int l=1; l<=5;++l) {
+ if(doLayer(l)) {
+ if(doBottom) makeModuleBundle(l,"bottom");
+ if(doTop) makeModuleBundle(l,"top");
+ }
+ }
+
+ if(isDebug()) {
+ System.out.printf("%s: DONE constructing the geometry objects\n", this.getClass().getSimpleName());
+ System.out.printf("%s: List of all the geometry objects built\n", this.getClass().getSimpleName());
+ for(SurveyVolume bg : surveyVolumes) {
+ System.out.printf("-------\n%s\n", bg.toString());
+ }
+ }
+
+ }
+
+
+
+
+ /**
+ * Create the module.
+ * @param layer - of the module
+ * @param half - top or bottom half of the tracker
+ */
+ protected void makeModuleBundle(int layer, String half)
+ {
+
+ if(isDebug()) System.out.printf("%s: makeModule for layer %d %s \n", this.getClass().getSimpleName(), layer, half);
+
+
+ // build the module name
+ String volName = "module_L"+ layer + (half=="bottom"?"b":"t");
+
+ boolean isL13 = ( layer >=1 && layer <=3 ) ? true : false;
+
+ // find the mother and reference geometry
+ // Note that the reference geometry is the support plate and since that is assumed to be
+ // created through it's references we don't need more than one reference to reach the mother coordinate system
+ final SurveyVolume mother;
+ final SurveyVolume ref;
+ if(half == "bottom") {
+ mother = getSurveyVolume(TrackerEnvelope.class);
+ ref = getSurveyVolume(SupportPlateBottom.class);
+ } else {
+ mother= getSurveyVolume(TrackerEnvelope.class);
+ ref = getSurveyVolume(SupportPlateTop.class);
+ }
+
+ //Create the module
+ TestRunModule module;
+ if(isL13) {
+ module = new TestRunModuleL13(volName, mother, ref, layer, half);
+ } else {
+ module = new TestRunModuleL45(volName, mother, ref, layer, half);
+ }
+
+
+ // create the bundle for this module
+ TestRunModuleBundle bundle = new TestRunModuleBundle(module);
+ addModuleBundle(bundle);
+
+ if(doAxial) makeHalfModule("axial", module);
+ if(doColdBlock) makeColdBlock(module);
+ if(doStereo) makeHalfModule("stereo", module);
+
+
+ if(isDebug()) {
+ System.out.printf("%s: created module bundle:\n", this.getClass().getSimpleName());
+ bundle.print();
+ }
+
+ }
+
+ /**
+ * Create the cold block object.
+ * @param mother to the cold block
+ */
+ protected void makeColdBlock(TestRunModule mother) {
+
+
+ String moduleName = mother.getName();
+
+ if(isDebug()) System.out.printf("%s: makeColdBlock for %s \n", this.getClass().getSimpleName(), moduleName);
+
+
+ String volName = moduleName + "_coldblock";
+
+ // find layer
+ int layer = getLayerFromVolumeName(moduleName);
+
+ // Build the half-module
+ TestRunColdBlock coldBlock;
+
+ if(layer >= 1 && layer <=3) {
+ coldBlock = new TestRunColdBlockL13(volName, mother, layer);
+ } else if(layer >= 4 && layer <=5) {
+ coldBlock = new TestRunColdBlockL45(volName, mother, layer);
+ } else {
+ throw new RuntimeException("wrong layer for " + volName);
+ }
+
+ TestRunModuleBundle bundle = (TestRunModuleBundle) getModuleBundle(mother);
+ bundle.coldBlock = coldBlock;
+ }
+
+
+
+
+ public static class TrackerEnvelope extends SurveyVolume {
+ // height of the dummy box holding the entire SVT:
+ // this means the bottom of the base plate to the the inner surface of of the PS vac box for now
+ public static final double base_height = PS_vac_box_inner_height - BasePlate.base_plate_offset_height;
+ public static final double base_width = BasePlate.base_plate_width;
+ public static final double base_length = BasePlate.base_plate_length;
+
+ public TrackerEnvelope(String name, SurveyVolume mother) {
+ super(name,mother, null);
+ init();
+ }
+ protected void setPos() {
+ final double ball_pos_base_x = -1.0*target_pos_wrt_base_plate_x;
+ final double ball_pos_base_y = -1.0*target_pos_wrt_base_plate_y;
+ final double ball_pos_base_z = target_pos_wrt_base_plate_z;
+ final double vee_pos_base_x = ball_pos_base_x + BasePlate.base_plate_width;
+ final double vee_pos_base_y = ball_pos_base_y;
+ final double vee_pos_base_z = ball_pos_base_z;
+ final double flat_pos_base_x = ball_pos_base_x;
+ final double flat_pos_base_y = ball_pos_base_y;
+ final double flat_pos_base_z = ball_pos_base_z - BasePlate.base_plate_length;
+ setBallPos(ball_pos_base_x,ball_pos_base_y,ball_pos_base_z);
+ setVeePos(vee_pos_base_x,vee_pos_base_y,vee_pos_base_z);
+ setFlatPos(flat_pos_base_x, flat_pos_base_y, flat_pos_base_z);
+ }
+ protected void setCenter() {
+ setCenter(base_width/2.0, base_length/2.0, base_height/2.0 - BasePlate.base_plate_thickness);
+ }
+ protected void setBoxDim() {
+ setBoxDim(base_width,base_length,base_height);
+ }
+ }
+
+
+
+ public static class BasePlate extends SurveyVolume {
+ // Base plate references
+ public static final double base_plate_thickness = 0.25*inch;
+ public static final double base_plate_width = 385.00;
+ public static final double base_plate_length = 1216.00;
+ //height from vacuum chamber surface
+ protected static final double base_plate_offset_height = 2.0; //from Marco's 3D model
+ public BasePlate(String name, SurveyVolume mother, String material) {
+ super(name,mother, null);
+ init();
+ setMaterial(material);
+ }
+ protected void setPos() {
+ setBallPos(0,0,0);
+ setVeePos(base_plate_width,ballPos.y(),ballPos.z());
+ setFlatPos(ballPos.x(),base_plate_length,ballPos.z());
+ }
+ protected void setCenter() {
+ setCenter(base_plate_width/2.0, base_plate_length/2.0, -base_plate_thickness/2.0);
+ }
+ protected void setBoxDim() {
+ setBoxDim(base_plate_width,base_plate_length, base_plate_thickness);
+ }
+ }
+
+
+
+
+ public static class CSupport extends SurveyVolume {
+ // This is the sequence of locating the support plate positions:
+ // The c-support pin positions are found
+ // the points on the axis of rotation are used as references for building the box surrounding the support plates (incl sensors).
+ // this should make it more straightforward when applying a tilt angle
+ // c-support:
+ // ball position is C-support pin position on electron side on the base plate surface
+ // vee position is C-support pin position on positron side on the base plate surface
+ // flat position is a randomly chosen point perpendicular to ball to vee vector and offset 10mm along the plate.
+ // Note that the flat here sets the tilt angle of the support plates.
+
+ // c-support references
+ // pin position on base plate surface
+ private static final double ball_pos_csup_pin_bottom_x = 51.15;
+ private static final double ball_pos_csup_pin_bottom_y = 115.02;
+ private static final double ball_pos_csup_pin_bottom_z = 0.0;
+ private static final double vee_pos_csup_pin_bottom_x = 271.05;
+ private static double vee_pos_csup_pin_bottom_y = 121.62;
+ private static double vee_pos_csup_pin_bottom_z = 0.0;
+
+
+ public CSupport(String name, SurveyVolume mother) {
+ super(name,mother, null);
+ init();
+ }
+ private void calcAndSetFlatPos() {
+ if(use30mradRotation) {
+ // find the rotation to place the flat point
+ Rotation rot1_csup =
+ new Rotation(
+ new Vector3D(vee_pos_csup_pin_bottom_x-ball_pos_csup_pin_bottom_x,
+ vee_pos_csup_pin_bottom_y-ball_pos_csup_pin_bottom_y,
+ vee_pos_csup_pin_bottom_z-ball_pos_csup_pin_bottom_z),
+ new Vector3D(1,0,0));
+
+ Vector3D flat_pos_csup_pin_bottom_3D_rot = rot1_csup.applyTo(new Vector3D(0,10.0,0));
+ // translate
+ double flat_pos_csup_pin_bottom_x = ball_pos_csup_pin_bottom_x + flat_pos_csup_pin_bottom_3D_rot.getX();
+ double flat_pos_csup_pin_bottom_y = ball_pos_csup_pin_bottom_y + flat_pos_csup_pin_bottom_3D_rot.getY();
+ double flat_pos_csup_pin_bottom_z = ball_pos_csup_pin_bottom_z + flat_pos_csup_pin_bottom_3D_rot.getZ();
+
+ setFlatPos(flat_pos_csup_pin_bottom_x,flat_pos_csup_pin_bottom_y,flat_pos_csup_pin_bottom_z);
+ if(debug) System.out.println("rotated setPos for csupport: \n" + getFlatPos().toString());
+
+ } else {
+
+ //vee_pos_csup_pin_bottom_x = ball_pos_csup_pin_bottom_x + 0;
+ vee_pos_csup_pin_bottom_y = ball_pos_csup_pin_bottom_y;
+ vee_pos_csup_pin_bottom_z = ball_pos_csup_pin_bottom_z + 0;
+
+ double flat_pos_csup_pin_bottom_x = ball_pos_csup_pin_bottom_x + 0;
+ double flat_pos_csup_pin_bottom_y = ball_pos_csup_pin_bottom_y + 10.0;
+ double flat_pos_csup_pin_bottom_z = ball_pos_csup_pin_bottom_z + 0;
+
+ setFlatPos(flat_pos_csup_pin_bottom_x,flat_pos_csup_pin_bottom_y,flat_pos_csup_pin_bottom_z);
+ if(debug) System.out.println("setPos for csupport: \n" + getFlatPos().toString());
+
+ }
+ }
+ protected void setPos() {
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+ calcAndSetFlatPos();
+ setBallPos(ball_pos_csup_pin_bottom_x,ball_pos_csup_pin_bottom_y,ball_pos_csup_pin_bottom_z);
+ setVeePos(vee_pos_csup_pin_bottom_x,vee_pos_csup_pin_bottom_y,vee_pos_csup_pin_bottom_z);
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ // this is never used since it's only a reference volume
+ setCenter(null);
+ }
+ protected void setBoxDim() {
+ }
+
+ }
+
+
+
+
+ public static class SupportTop extends SurveyVolume {
+ // Top only needs a vertical offset to be specified
+ private static final double ball_pos_csup_bearings_top_z = 146.4;
+ //these are for the box surrounding the whole support including modules
+ protected static final double support_top_length = SupportBottom.support_bottom_length;
+ protected static final double support_top_width = SupportBottom.support_bottom_width;
+ protected static final double support_top_height = SupportBottom.support_bottom_height;
+
+ public SupportTop(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name,mother, alignmentCorrection);
+ init();
+ }
+ public SupportTop(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, SurveyVolume referenceGeom) {
+ super(name,mother,alignmentCorrection, referenceGeom);
+ init();
+ }
+ public SupportTop(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, List<SurveyVolume> referenceGeom) {
+ super(name,mother,alignmentCorrection, referenceGeom);
+ init();
+ }
+
+ protected void setPos() {
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+ // the top has the same bearing positions as the bottom c-support except for the offset vertically from base plate
+ // the tilt angle is independent though.
+ setBallPos(SupportBottom.ball_pos_csup_bearings_bottom_x, SupportBottom.ball_pos_csup_bearings_bottom_y, ball_pos_csup_bearings_top_z);
+ setVeePos(SupportBottom.vee_pos_csup_bearings_bottom_x, SupportBottom.vee_pos_csup_bearings_bottom_y, ball_pos_csup_bearings_top_z);
+ // build the rotation to find the proper location of the flat
+ Rotation rot_csup_top =
+ new Rotation(RotationOrder.XYZ,
+ SupportPlateTop.support_plate_top_tilt_angle, 0.0, 0.0 );
+
+ // apply to flat local position (as for bottom it is an arbitrary offset)
+ Vector3D flat_pos_csup_bearings_top_3D_rot =
+ rot_csup_top.applyTo(new Vector3D(0.0,10.0,0.0));
+
+ // translate the flat position
+ final double flat_pos_csup_bearings_top_x = getBallPos().x() + flat_pos_csup_bearings_top_3D_rot.getX();
+ final double flat_pos_csup_bearings_top_y = getBallPos().y() + flat_pos_csup_bearings_top_3D_rot.getY();
+ final double flat_pos_csup_bearings_top_z = getBallPos().z() + flat_pos_csup_bearings_top_3D_rot.getZ();
+ setFlatPos(flat_pos_csup_bearings_top_x,flat_pos_csup_bearings_top_y,flat_pos_csup_bearings_top_z);
+
+ // since we don't care (no volume is built) about the local position of the bearings in the pin coord system we'll get rid of it
+ // and find the bearings position in the base coordinate system directly
+ if(referenceGeom==null) {
+ throw new RuntimeException("No ref found for " + getName());
+ }
+ /*
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) {
+ System.out.printf("%s: survey positions before ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+
+ if(debug) System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+
+ ref.getCoord().getTransformation().transform(ballPos);
+ ref.getCoord().getTransformation().transform(veePos);
+ ref.getCoord().getTransformation().transform(flatPos);
+
+ if(debug) {
+ System.out.printf("%s: survey positions after ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+ }
+ */
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ setCenter(support_top_width/2.0+1.0, support_top_length/2.0 + (17.00-10.50/2.0), -1.0 * (support_top_height/2.0 - (12.70-6.66-1.34)));
+ }
+ protected void setBoxDim() {
+ setBoxDim(support_top_width,support_top_length,support_top_height);
+ }
+ /*
+ protected void applyReferenceTransformation() {
+
+ if(debug) {
+ System.out.printf("%s: coord system before ref transformations:\n%s\n",this.getClass().getSimpleName(),getCoord().toString());
+ }
+
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) {
+ //System.out.printf("%s: survey positions before ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ //printSurveyPos();
+ System.out.printf("%s: coord system before ref %s transform:\n%s\n",this.getClass().getSimpleName(),ref.getName(),getCoord().toString());
+ }
+
+ if(debug) System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+
+ getCoord().transform(ref.getCoord().getTransformation());
+
+ //ref.getCoord().getTransformation().transform(ballPos);
+ //ref.getCoord().getTransformation().transform(veePos);
+ //ref.getCoord().getTransformation().transform(flatPos);
+
+ if(debug) {
+ //System.out.printf("%s: survey positions after ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ //printSurveyPos();
+ System.out.printf("%s: coord system after ref %s transform:\n%s\n",this.getClass().getSimpleName(),ref.getName(),getCoord().toString());
+ }
+ }
+
+ if(debug) {
+ System.out.printf("%s: coord system after ref transformations:\n%s\n",this.getClass().getSimpleName(),getCoord().toString());
+ }
+
+
+ }
+ */
+ }
+
+
+
+ public static class SupportBottom extends SurveyVolume {
+ // "bearings" are points on axis of rotation on the inside of the c-support frame where the insert get's attached
+ // this is referenced to the pin position of the c-support
+ private static final double ball_pos_csup_bearings_bottom_x = 240.0 - 265.0 + 14.0;
+ private static final double ball_pos_csup_bearings_bottom_y = (-6.0 + 22.0);
+ private static final double ball_pos_csup_bearings_bottom_z = 14.7;
+ private static final double vee_pos_csup_bearings_bottom_x = 240.0- 129.0;
+ private static final double vee_pos_csup_bearings_bottom_y = (-6.0 + 22.0);
+ private static final double vee_pos_csup_bearings_bottom_z = 14.7;
+
+ //these are for the box surrounding the whole support including modules
+ protected static final double support_bottom_length = SupportPlateBottom.support_plate_bottom_length;
+ protected static final double support_bottom_width = (25.0-5.0) + TestRunModuleL13.module_box_L13_length;
+ protected static final double support_bottom_height = SupportPlateBottom.support_plate_bottom_height - SupportPlateBottom.support_plate_pocket_depth + TestRunModuleL13.module_box_L13_width + SupportPlateBottom.pedestal_height_L1;
+
+
+ public SupportBottom(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, SurveyVolume referenceGeom) {
+ super(name,mother,alignmentCorrection, referenceGeom);
+ init();
+ }
+
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ // now create the support box which will have it's coordinates at the rotation axis so that the flat determines the tilt of the plates
+ // it is referenced locally to the c-support pin coordinate system here
+
+ // build the rotation to find the proper location of the flat
+ Rotation rot_csup =
+ new Rotation(RotationOrder.XYZ,
+ SupportPlateBottom.support_plate_bottom_tilt_angle, 0.0, 0.0 );
+ // apply to flat local position
+ Vector3D flat_pos_csup_bearings_bottom_3D_rot =
+ rot_csup.applyTo(new Vector3D(0.0,10.0,0.0));
+ // translate
+ final double flat_pos_csup_bearings_bottom_x = ball_pos_csup_bearings_bottom_x + flat_pos_csup_bearings_bottom_3D_rot.getX();
+ final double flat_pos_csup_bearings_bottom_y = ball_pos_csup_bearings_bottom_y + flat_pos_csup_bearings_bottom_3D_rot.getY();
+ final double flat_pos_csup_bearings_bottom_z = ball_pos_csup_bearings_bottom_z + flat_pos_csup_bearings_bottom_3D_rot.getZ();
+
+ // make vectors
+ setBallPos(ball_pos_csup_bearings_bottom_x,ball_pos_csup_bearings_bottom_y,ball_pos_csup_bearings_bottom_z);
+ setVeePos(vee_pos_csup_bearings_bottom_x,vee_pos_csup_bearings_bottom_y,vee_pos_csup_bearings_bottom_z);
+ setFlatPos(flat_pos_csup_bearings_bottom_x,flat_pos_csup_bearings_bottom_y,flat_pos_csup_bearings_bottom_z);
+
+
+ // create the coordinate system of the c-support bearings
+ //HPSTestRunTracker2014GeomDef.Coord csup_bearings_bottom_coord = new HPSTestRunTracker2014GeomDef.Coord(ball_pos_csup_bearings_bottom, vee_pos_csup_bearings_bottom, flat_pos_csup_bearings_bottom);
+
+ // since we don't care (no volume is built) about the local position of the bearings in the pin coord system we'll get rid of it
+ // and find the bearings position in the base coordinate system directly
+ if(referenceGeom==null) {
+ throw new RuntimeException("No ref found for " + getName());
+ }
+ /*
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) {
+ System.out.printf("%s: survey positions before ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+
+ if(debug) System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+
+ ref.getCoord().getTransformation().transform(ballPos);
+ ref.getCoord().getTransformation().transform(veePos);
+ ref.getCoord().getTransformation().transform(flatPos);
+
+ if(debug) {
+ System.out.printf("%s: survey positions after ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+ }
+ */
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ }
+ protected void setCenter() {
+ setCenter(support_bottom_width/2.0+1.0, support_bottom_length/2.0 + (17.00-10.50/2.0), support_bottom_height/2.0 - (12.70-6.66-1.34));
+ }
+ protected void setBoxDim() {
+ setBoxDim(support_bottom_width,support_bottom_length,support_bottom_height);
+ }
+
+ }
+
+
+ protected static abstract class SupportPlate extends SurveyVolume {
+ protected static final double support_plate_pocket_depth = 6.65; // Tim's sketchup, drawing says 6.66mm?
+ protected static final double pedestal_height_L1 = 11.00;
+ protected static final double pedestal_height_L2 = 9.50;
+ protected static final double pedestal_height_L3 = 8.00;
+ protected static final double pedestal_height_L4 = 10.00;
+ protected static final double pedestal_height_L5 = 7.00;
+ public SupportPlate(SurveyVolume mother, SurveyVolume referenceGeom, String name, String material) {
+ super(name,mother,null, referenceGeom);
+ setMaterial(material);
+ }
+ public SupportPlate(SurveyVolume mother, List<SurveyVolume> referenceGeom, String name, String material) {
+ super(name,mother,null, referenceGeom);
+ setMaterial(material);
+ }
+
+ }
+
+
+
+
+
+ public static class SupportPlateBottom extends SupportPlate {
+ // support plate references
+ // use a settable rotation to effectively determine the flat and therefore the tilt of the support
+ protected static final double support_plate_bottom_tilt_angle = 0.0;
+ protected static final double support_plate_bottom_height = 12.7;
+ protected static final double support_plate_bottom_length = 736.1;
+ protected static final double support_plate_bottom_width = 120.0;
+
+ public SupportPlateBottom(String name, SurveyVolume mother, SurveyVolume referenceGeom, String material) {
+ super(mother, referenceGeom, name, material);
+ init();
+ }
+ public SupportPlateBottom(String name, SurveyVolume mother, List<SurveyVolume> referenceGeom, String material) {
+ super(mother, referenceGeom, name, material);
+ init();
+ }
+ protected void setPos() {
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ ballPos = new BasicHep3Vector(1.0, (17.0-5.0), 6.66+1.34);
+ veePos = new BasicHep3Vector(ballPos.x() + support_plate_bottom_length, ballPos.y(),ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y() + support_plate_bottom_length,ballPos.z());
+
+ if(referenceGeom==null) {
+ throw new RuntimeException("No ref found for " + getName());
+ }
+ /*
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) {
+ System.out.printf("%s: survey positions before ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+
+ if(debug) System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+
+ ref.getCoord().getTransformation().transform(ballPos);
+ ref.getCoord().getTransformation().transform(veePos);
+ ref.getCoord().getTransformation().transform(flatPos);
+
+ if(debug) {
+ System.out.printf("%s: survey positions after ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+ }
+ */
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ setCenter(support_plate_bottom_width/2.0, support_plate_bottom_length/2.0, -1.0 * support_plate_bottom_height/2.0);
+ }
+ @Override
+ protected void setBoxDim() {
+ setBoxDim(support_plate_bottom_width,support_plate_bottom_length,support_plate_bottom_height);
+ }
+ }
+
+
+ public static class SupportPlateTop extends SupportPlate {
+ // support plate references
+ // use a settable rotation to effectively determine the flat and therefore the tilt of the support
+ protected static final double support_plate_top_tilt_angle = 0.0;
+ protected static final double support_plate_top_length = SupportPlateBottom.support_plate_bottom_length;
+ protected static final double support_plate_top_width = SupportPlateBottom.support_plate_bottom_width;
+ protected static final double support_plate_top_height = SupportPlateBottom.support_plate_bottom_height;
+
+ public SupportPlateTop(String name, SurveyVolume mother, SurveyVolume referenceGeom, String material) {
+ super(mother,referenceGeom, name,material);
+ init();
+ }
+ protected void setPos() {
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ ballPos = new BasicHep3Vector(1.0, (17.0-5.0), -1.0 * (6.66+1.34));
+ veePos = new BasicHep3Vector(ballPos.x() + support_plate_top_width, ballPos.y(),ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y() + support_plate_top_length,ballPos.z());
+
+ if(referenceGeom==null) {
+ throw new RuntimeException("No ref found for " + getName());
+ }
+ /*
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) System.out.printf("%s: survey positions before ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ if(debug) printSurveyPos();
+
+ if(debug) System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+
+ ref.getCoord().getTransformation().transform(ballPos);
+ ref.getCoord().getTransformation().transform(veePos);
+ ref.getCoord().getTransformation().transform(flatPos);
+
+ if(debug) System.out.printf("%s: survey positions after ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ if(debug) printSurveyPos();
+ }
+ */
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ setCenter(support_plate_top_width/2.0, support_plate_top_length/2.0, support_plate_top_height/2.0);
+ }
+ @Override
+ protected void setBoxDim() {
+ setBoxDim(support_plate_top_width, support_plate_top_length, support_plate_top_height);
+ }
+ }
+
+
+
+
+ public static class TestRunModuleL45 extends TestRunModule {
+
+ protected static final double module_box_L45_length = 205.2 + box_extra_length; // includes lexan spacer and cold block
+ protected static final double module_box_L45_height = 12.5 + box_extra_height; // includes screws height
+ protected static final double module_box_L45_width = 65.3-12.0 + box_extra_width;
+ protected static final double dist_lower_sensor_edge_to_cold_block_mounting_surface = 7.662;
+
+
+ public TestRunModuleL45(String name, SurveyVolume mother, int layer,String half) {
+ super(name, mother, layer, half);
+ }
+ public TestRunModuleL45(String name, SurveyVolume mother, SurveyVolume ref, int layer, String half) {
+ super(name, mother, ref, layer, half);
+ }
+ protected double getColdBlockThickness() {
+ return TestRunColdBlockL45.coldblock_L45_thickness;
+ }
+ protected double getModuleBoxLength() {
+ return module_box_L45_length;
+ }
+ protected double getModuleBoxWidth() {
+ return module_box_L45_width;
+ }
+ protected double getModuleBoxHeight() {
+ return module_box_L45_height;
+ }
+ protected double get_dist_lower_sensor_edge_to_cold_block_mounting_surface() {
+ return dist_lower_sensor_edge_to_cold_block_mounting_surface;
+ }
+
+ }
+
+ public static class TestRunModuleL13 extends TestRunModule {
+ protected static final double module_box_L13_length = 205.2 + box_extra_length; // includes lexan spacer and cold block
+ protected static final double module_box_L13_height = 12.5 + box_extra_height; // includes screws height
+ protected static final double module_box_L13_width = 71.3 - 13.0 + box_extra_width; // height from cold block to encapsulate the whole module
+ protected static final double dist_lower_sensor_edge_to_cold_block_mounting_surface = 12.66;
+
+ public TestRunModuleL13(String name, SurveyVolume mother, int layer, String half) {
+ super(name, mother, layer, half);
+ }
+ public TestRunModuleL13(String name, SurveyVolume mother, SurveyVolume ref, int layer, String half) {
+ super(name, mother, ref, layer, half);
+ }
+ protected double getColdBlockThickness() {
+ return TestRunColdBlockL13.coldblock_L13_thickness;
+ }
+ protected double getModuleBoxLength() {
+ return module_box_L13_length;
+ }
+ protected double getModuleBoxWidth() {
+ return module_box_L13_width;
+ }
+ protected double getModuleBoxHeight() {
+ return module_box_L13_height;
+ }
+ protected double get_dist_lower_sensor_edge_to_cold_block_mounting_surface() {
+ return dist_lower_sensor_edge_to_cold_block_mounting_surface;
+ }
+ }
+
+
+ public static abstract class TestRunModule extends BaseModule {
+ protected final static double box_extra_length = 10.0;// random at this point
+ protected final static double box_extra_width = 15.0;// random at this point
+ protected final static double box_extra_height = 1.0;// random at this point
+
+ public TestRunModule(String name, SurveyVolume mother, int layer, String half) {
+ super(name, mother,null,layer, half);
+ init();
+ }
+ public TestRunModule(String name, SurveyVolume mother, SurveyVolume ref, int layer, String half) {
+ super(name, mother,null,ref,layer, half);
+ init();
+ }
+ protected abstract double getColdBlockThickness();
+ protected abstract double getModuleBoxLength();
+ protected abstract double getModuleBoxWidth();
+ protected abstract double getModuleBoxHeight();
+ protected abstract double get_dist_lower_sensor_edge_to_cold_block_mounting_surface();
+
+ protected void setBoxDim() {
+ setBoxDim(getModuleBoxLength(),getModuleBoxHeight(),getModuleBoxWidth());
+ }
+ protected void setCenter() {
+ setCenter(getModuleBoxLength()/2.0-5.0, 0.0, getModuleBoxWidth()/2.0-box_extra_width/5.0);
+ }
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+
+ if(isBottom()) {
+ switch (getLayer()) {
+ case 1:
+ ballPos = new BasicHep3Vector(25.0, 661.1, SupportPlateBottom.pedestal_height_L1-SupportPlateBottom.support_plate_pocket_depth);
+ veePos = new BasicHep3Vector(95.0, 661.1, SupportPlateBottom.pedestal_height_L1-SupportPlateBottom.support_plate_pocket_depth);
+ flatPos = new BasicHep3Vector(60.0, 667.10, SupportPlateBottom.pedestal_height_L1-SupportPlateBottom.support_plate_pocket_depth);
+ break;
+ case 2:
+ ballPos = new BasicHep3Vector(25.0, 561.1, SupportPlateBottom.pedestal_height_L2-SupportPlateBottom.support_plate_pocket_depth);
+ veePos = new BasicHep3Vector(95.0, 561.1, SupportPlateBottom.pedestal_height_L2-SupportPlateBottom.support_plate_pocket_depth);
+ flatPos = new BasicHep3Vector(60.0, 567.10, SupportPlateBottom.pedestal_height_L2-SupportPlateBottom.support_plate_pocket_depth);
+ break;
+ case 3:
+ ballPos = new BasicHep3Vector(25.0, 461.1, SupportPlateBottom.pedestal_height_L3-SupportPlateBottom.support_plate_pocket_depth);
+ veePos = new BasicHep3Vector(95.0, 461.1, SupportPlateBottom.pedestal_height_L3-SupportPlateBottom.support_plate_pocket_depth);
+ flatPos = new BasicHep3Vector(60.0, 467.10, SupportPlateBottom.pedestal_height_L3-SupportPlateBottom.support_plate_pocket_depth);
+ break;
+ case 4:
+ ballPos = new BasicHep3Vector(25.0, 261.1, SupportPlateBottom.pedestal_height_L4-SupportPlateBottom.support_plate_pocket_depth);
+ veePos = new BasicHep3Vector(95.0, 261.1, SupportPlateBottom.pedestal_height_L4-SupportPlateBottom.support_plate_pocket_depth);
+ flatPos = new BasicHep3Vector(60.0, 267.10, SupportPlateBottom.pedestal_height_L4-SupportPlateBottom.support_plate_pocket_depth);
+ break;
+ case 5:
+ ballPos = new BasicHep3Vector(25.0, 61.1, SupportPlateBottom.pedestal_height_L5-SupportPlateBottom.support_plate_pocket_depth);
+ veePos = new BasicHep3Vector(95.0, 61.1, SupportPlateBottom.pedestal_height_L5-SupportPlateBottom.support_plate_pocket_depth);
+ flatPos = new BasicHep3Vector(60.0, 67.10, SupportPlateBottom.pedestal_height_L5-SupportPlateBottom.support_plate_pocket_depth);
+ break;
+ default:
+ System.out.printf("ERROR invalid layer %d for half %s\n",getLayer(),getHalf());
+ System.exit(1);
+ break;
+ }
+
+ } else {
+ // top
+ // top has a fixed offset of 15mm along plate on module pocket positions w.r.t. bottom
+ // top local coordinates is rotation pi around u-vec so need to adjust pocket depth coordinate
+
+ switch (getLayer()) {
+ case 1:
+ ballPos = new BasicHep3Vector(25.0, 676.1, -1.0 * (SupportPlateBottom.pedestal_height_L1-SupportPlateBottom.support_plate_pocket_depth));
+ veePos = new BasicHep3Vector(95.0, 676.1, -1.0 * (SupportPlateBottom.pedestal_height_L1-SupportPlateBottom.support_plate_pocket_depth));
+ flatPos = new BasicHep3Vector(60.0, 670.1, -1.0 * (SupportPlateBottom.pedestal_height_L1-SupportPlateBottom.support_plate_pocket_depth));
+ break;
+ case 2:
+ ballPos = new BasicHep3Vector(25.0, 576.1, -1.0 * (SupportPlateBottom.pedestal_height_L2-SupportPlateBottom.support_plate_pocket_depth));
+ veePos = new BasicHep3Vector(95.0, 576.1, -1.0 * (SupportPlateBottom.pedestal_height_L2-SupportPlateBottom.support_plate_pocket_depth));
+ flatPos = new BasicHep3Vector(60.0, 570.1, -1.0 * (SupportPlateBottom.pedestal_height_L2-SupportPlateBottom.support_plate_pocket_depth));
+ break;
+ case 3:
+ ballPos = new BasicHep3Vector(25.0, 476.1, -1.0 * (SupportPlateBottom.pedestal_height_L3-SupportPlateBottom.support_plate_pocket_depth));
+ veePos = new BasicHep3Vector(95.0, 476.1, -1.0 * (SupportPlateBottom.pedestal_height_L3-SupportPlateBottom.support_plate_pocket_depth));
+ flatPos =new BasicHep3Vector(60.0, 470.1, -1.0 * (SupportPlateBottom.pedestal_height_L3-SupportPlateBottom.support_plate_pocket_depth));
+ break;
+ case 4:
+ ballPos = new BasicHep3Vector(25.0, 276.1, -1.0 * (SupportPlateBottom.pedestal_height_L4-SupportPlateBottom.support_plate_pocket_depth));
+ veePos = new BasicHep3Vector(95.0, 276.1, -1.0 * (SupportPlateBottom.pedestal_height_L4-SupportPlateBottom.support_plate_pocket_depth));
+ flatPos = new BasicHep3Vector(60.0, 270.1, -1.0 * (SupportPlateBottom.pedestal_height_L4-SupportPlateBottom.support_plate_pocket_depth));
+ break;
+ case 5:
+ ballPos = new BasicHep3Vector(25.0, 76.1, -1.0 * (SupportPlateBottom.pedestal_height_L5-SupportPlateBottom.support_plate_pocket_depth));
+ veePos = new BasicHep3Vector(95.0, 76.1, -1.0 * (SupportPlateBottom.pedestal_height_L5-SupportPlateBottom.support_plate_pocket_depth));
+ flatPos = new BasicHep3Vector(60.0, 70.1, -1.0 * (SupportPlateBottom.pedestal_height_L5-SupportPlateBottom.support_plate_pocket_depth));
+ break;
+ default:
+ System.out.printf("ERROR invalid layer %d for half %s\n",getLayer(),getHalf());
+ System.exit(1);
+ break;
+ }
+ }
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ /*
+ // walk through the reference volumes
+ if(referenceGeom!=null) {
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) {
+ System.out.printf("%s: survey positions before ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+
+ if(debug) System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+
+ ref.getCoord().getTransformation().transform(ballPos);
+ ref.getCoord().getTransformation().transform(veePos);
+ ref.getCoord().getTransformation().transform(flatPos);
+
+ if(debug) {
+ System.out.printf("%s: survey positions after ref %s transform\n",this.getClass().getSimpleName(),ref.getName());
+ printSurveyPos();
+ }
+ }
+ }
+ */
+
+ }
+
+ }
+
+
+ public static abstract class BaseModule extends SurveyVolume {
+ protected int layer;
+ protected String half;
+
+ public BaseModule(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection);
+ setLayer(layer);
+ setHalf(half);
+ isValid();
+ }
+ public BaseModule(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, SurveyVolume ref, int layer, String half) {
+ super(name, mother, alignmentCorrection, ref);
+ setLayer(layer);
+ setHalf(half);
+ isValid();
+ }
+ private void isValid() {
+ if(half!="bottom" && half!="top") {
+ System.out.printf("ERROR invalid half %s for BaseModule\n",half);
+ System.exit(1);
+ }
+ }
+ public int getLayer() {
+ return layer;
+ }
+ public void setLayer(int layer) {
+ this.layer = layer;
+ }
+
+ public String getHalf() {
+ return half;
+ }
+
+ public void setHalf(String half) {
+ this.half = half;
+ }
+
+ public boolean isBottom() {
+ return getHalf() == "bottom" ? true : false;
+ }
+
+ }
+
+
+
+ public abstract static class TestRunHalfModule extends BaseModule {
+
+ // Find the coordinate system of the half-modules w.r.t. to the module survey points
+ // We are going to know the sensor center position w.r.t. module coordinate system so the half-module
+ // is really just a dummy volume to contain the daughters. Therefore place it at the same place
+ // as where the sensor coordinate system will be to make things simpler.
+
+ // Distance from sensor to CF edge: 180mm
+ // Distance from CF edge to screw hole: 30mm
+ // Distance from screw hole to edge of cold block: 33.75mm
+ // Distance from edge of cold block to hole/ball position: 5mm
+ protected static final double dist_sensor_center_to_coldblock_hole_vdir = (180.0 - 30.0 + (33.75 - 5.0)) - Sensor.length/2.0;
+ protected static final double half_module_thickness = TestRunHalfModule.getHybridThickness() + TestRunHalfModule.getCFThickness() + HalfModuleLamination.thickness;
+ protected static final double half_module_length = TestRunHalfModule.getCFLength();
+ protected static final double half_module_width = 6.83 + Sensor.width;
+
+ protected double stereo_angle = 0.0;
+
+ public TestRunHalfModule(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name,mother, alignmentCorrection, layer, half);
+ }
+
+ protected void setCenter() {
+ // Find distance to center in the local coordinate system
+ // Note that this can be different between axial and stereo since the survey positions determine the local coordinate
+ // system now.
+ // I'm not sure this feels good but this has to be done somewhere
+// double box_center_local_x = TestRunHalfModule.getLength()/2.0 - ( (170.00 + 10.00) - Sensor.getSensorLength()/2.0);
+// double box_center_local_y = -1.0*TestRunHalfModule.getThickness()/2.0 + (TestRunHalfModule.getCFThickness() + HalfModuleLamination.kapton_thickness + Sensor.getSensorThickness()/2.0);
+// double box_center_local_z = TestRunHalfModule.getWidth()/2.0 - ( 12.66 - (8.83 -3.00) + Sensor.width/2.0 );
+
+ double box_center_local_x = TestRunHalfModule.getLength()/2.0 - ( (170.00 + 10.00) - Sensor.length/2.0);
+ double box_center_local_y = - Sensor.getSensorThickness()/2.0 - HalfModuleLamination.thickness - CarbonFiber.thickness + half_module_thickness/2.0;
+ double box_center_local_z = TestRunHalfModule.getWidth()/2.0 - ( 12.66 - (8.83 -3.00) + Sensor.width/2.0 );
+
+
+ if(useSiStripsConvention) {
+ //setCenter(box_center_local_z, box_center_local_x, box_center_local_y);
+ setCenter(-1.0*box_center_local_z, box_center_local_x, box_center_local_y);
+ } else {
+ setCenter(box_center_local_x, box_center_local_y, box_center_local_z);
+ }
+ }
+ protected void setBoxDim() {
+ //setBoxDim(getLength(), getThickness(), getWidth());
+
+ if(useSiStripsConvention) {
+ setBoxDim(getWidth(),getLength(),getThickness());
+ //setBoxDim(getSensorWidth(),getSensorLength(),getSensorThickness());
+ } else {
+ setBoxDim(getLength(), getThickness(), getWidth());
+ //setBoxDim(getSensorLength(),getSensorThickness(),getSensorWidth());
+ }
+
+ }
+ protected double getStereoAngle() {
+ return stereo_angle;
+ }
+ protected void setStereoAngle(double stereo_angle) {
+ this.stereo_angle = stereo_angle;
+ }
+ public static double getCFThickness() {
+ return CarbonFiber.thickness;
+ }
+ public static double getCFLength() {
+ return CarbonFiber.length;
+ }
+ public static double getCFWidth() {
+ return CarbonFiber.width;
+ }
+ public static double getHybridLength() {
+ return Hybrid.hybrid_length;
+ }
+ public static double getHybridWidth() {
+ return Hybrid.hybrid_width;
+ }
+ public static double getHybridThickness() {
+ return Hybrid.hybrid_thickness;
+ }
+ public static double getThickness() {
+ return half_module_thickness;
+ }
+ public static double getLength() {
+ return half_module_length;
+ }
+ public static double getWidth() {
+ return half_module_width;
+ }
+
+
+ }
+
+
+ public static class TestRunHalfModuleAxial extends TestRunHalfModule {
+
+ public TestRunHalfModuleAxial(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+
+ protected void setPos() {
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ final double coldBlockThick = getLayer() <=3 ? TestRunColdBlockL13.coldblock_L13_thickness : TestRunColdBlockL45.coldblock_L45_thickness;
+ final double dist_lower_sensor_edge_to_cold_block_mounting_surface = getLayer() <=3 ? TestRunModuleL13.dist_lower_sensor_edge_to_cold_block_mounting_surface : TestRunModuleL45.dist_lower_sensor_edge_to_cold_block_mounting_surface;
+
+ double ball_pos_halfmod_local_x = dist_sensor_center_to_coldblock_hole_vdir;
+ double ball_pos_halfmod_local_y = -1.0* (coldBlockThick/2.0 + TestRunHalfModule.getCFThickness() + HalfModuleLamination.thickness + Sensor.getSensorThickness()/2.0);
+ if(useFakeHalfModuleAxialPos) {
+ ball_pos_halfmod_local_x = ball_pos_halfmod_local_x*2.0;
+ ball_pos_halfmod_local_y = -2.0*ball_pos_halfmod_local_y;
+ }
+ final double ball_pos_halfmod_local_z = dist_lower_sensor_edge_to_cold_block_mounting_surface + Sensor.width/2.0;
+
+
+ double vee_pos_halfmod_local_x;
+ double vee_pos_halfmod_local_y;
+ double vee_pos_halfmod_local_z;
+ double flat_pos_halfmod_local_x;
+ double flat_pos_halfmod_local_y;
+ double flat_pos_halfmod_local_z;
+
+
+ if(useSiStripsConvention) {
+// vee_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+// vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+// vee_pos_halfmod_local_z = ball_pos_halfmod_local_z + Sensor.width/2.0;
+// flat_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.getSensorLength()/2.0;
+// flat_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+// flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+ vee_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+ vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ vee_pos_halfmod_local_z = ball_pos_halfmod_local_z - Sensor.width/2.0;
+ flat_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.length/2.0;
+ flat_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+
+ } else {
+ vee_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.length/2.0;
+ vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ vee_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+ flat_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+ flat_pos_halfmod_local_y = ball_pos_halfmod_local_y + Sensor.getSensorThickness()/2.0;
+ flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+ }
+ ballPos = new BasicHep3Vector(ball_pos_halfmod_local_x, ball_pos_halfmod_local_y, ball_pos_halfmod_local_z);
+ veePos = new BasicHep3Vector(vee_pos_halfmod_local_x, vee_pos_halfmod_local_y,vee_pos_halfmod_local_z);
+ flatPos = new BasicHep3Vector(flat_pos_halfmod_local_x, flat_pos_halfmod_local_y,flat_pos_halfmod_local_z);
+
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ }
+
+
+
+ }
+
+
+ public static class TestRunHalfModuleStereo extends TestRunHalfModule {
+
+ public TestRunHalfModuleStereo(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ if(layer<=3) stereo_angle = -0.1;
+ else if(layer>=4&&layer<=5) stereo_angle = -0.05;
+ else throw new RuntimeException("Layer " + layer + " is not defined.");
+ init();
+ //setExplicitRotation();
+ }
+
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ //very similar to axial, see note below
+
+ final double coldBlockThick = getLayer() <=3 ? TestRunColdBlockL13.coldblock_L13_thickness : TestRunColdBlockL45.coldblock_L45_thickness;
+ final double dist_lower_sensor_edge_to_cold_block_mounting_surface = getLayer() <=3 ? TestRunModuleL13.dist_lower_sensor_edge_to_cold_block_mounting_surface : TestRunModuleL45.dist_lower_sensor_edge_to_cold_block_mounting_surface;
+
+// final double ball_pos_halfmod_local_x = dist_sensor_center_to_coldblock_hole_vdir;
+// // note minus sign to separate from axial
+// final double ball_pos_halfmod_local_y = -1.0 * (-1.0* (coldBlockThick/2.0 + TestRunHalfModule.getCFThickness() + HalfModuleLamination.kapton_thickness + Sensor.getSensorThickness()/2.0));
+// final double ball_pos_halfmod_local_z = dist_lower_sensor_edge_to_cold_block_mounting_surface + Sensor.width/2.0;
+// final double vee_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.getSensorLength()/2.0;
+// final double vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+// final double vee_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+// final double flat_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+// final double flat_pos_halfmod_local_y = ball_pos_halfmod_local_y + Sensor.getSensorThickness()/2.0;
+// final double flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+// ballPos = new BasicHep3Vector(ball_pos_halfmod_local_x, ball_pos_halfmod_local_y, ball_pos_halfmod_local_z);
+// veePos = new BasicHep3Vector(vee_pos_halfmod_local_x, vee_pos_halfmod_local_y,vee_pos_halfmod_local_z);
+// flatPos = new BasicHep3Vector(flat_pos_halfmod_local_x, flat_pos_halfmod_local_y,flat_pos_halfmod_local_z);
+
+ double ball_pos_halfmod_local_x;
+ double ball_pos_halfmod_local_y;
+ double ball_pos_halfmod_local_z;
+ double vee_pos_halfmod_local_x;
+ double vee_pos_halfmod_local_y;
+ double vee_pos_halfmod_local_z;
+ double flat_pos_halfmod_local_x;
+ double flat_pos_halfmod_local_y;
+ double flat_pos_halfmod_local_z;
+
+ ball_pos_halfmod_local_x = dist_sensor_center_to_coldblock_hole_vdir;
+ // note minus sign to separate from axial
+ ball_pos_halfmod_local_y = -1.0 * (-1.0* (coldBlockThick/2.0 + TestRunHalfModule.getCFThickness() + HalfModuleLamination.thickness + Sensor.getSensorThickness()/2.0));
+ ball_pos_halfmod_local_z = dist_lower_sensor_edge_to_cold_block_mounting_surface + Sensor.width/2.0;
+
+ if(useSiStripsConvention) {
+
+// vee_pos_halfmod_local_x = ball_pos_halfmod_local_x ;
+// vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+// vee_pos_halfmod_local_z = ball_pos_halfmod_local_z + Sensor.width/2.0;
+// flat_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.getSensorLength()/2.0;
+// flat_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+// flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+
+
+
+ // vee_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+ // vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ // vee_pos_halfmod_local_z = ball_pos_halfmod_local_z - Sensor.width/2.0;
+ // flat_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.getSensorLength()/2.0;
+ // flat_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ // flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+
+
+ vee_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+ vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ vee_pos_halfmod_local_z = ball_pos_halfmod_local_z - Sensor.width/2.0;
+ flat_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.length/2.0;
+ flat_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+
+
+ } else {
+
+ vee_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.length/2.0;
+ vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+ vee_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+ flat_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+ flat_pos_halfmod_local_y = ball_pos_halfmod_local_y + Sensor.getSensorThickness()/2.0;
+ flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+
+
+
+//
+// vee_pos_halfmod_local_x = ball_pos_halfmod_local_x + Sensor.getSensorLength()/2.0;
+// vee_pos_halfmod_local_y = ball_pos_halfmod_local_y;
+// vee_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+// flat_pos_halfmod_local_x = ball_pos_halfmod_local_x;
+// flat_pos_halfmod_local_y = ball_pos_halfmod_local_y + Sensor.getSensorThickness()/2.0;
+// flat_pos_halfmod_local_z = ball_pos_halfmod_local_z;
+ }
+
+
+
+
+
+ ballPos = new BasicHep3Vector(ball_pos_halfmod_local_x, ball_pos_halfmod_local_y, ball_pos_halfmod_local_z);
+ veePos = new BasicHep3Vector(vee_pos_halfmod_local_x, vee_pos_halfmod_local_y,vee_pos_halfmod_local_z);
+ flatPos = new BasicHep3Vector(flat_pos_halfmod_local_x, flat_pos_halfmod_local_y,flat_pos_halfmod_local_z);
+
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ }
+
+
+
+
+
+ protected void applyGenericCoordinateSystemCorrections() {
+ // Apply whatever corrections we want to the final volume as created
+ // Maybe alignment corrections too but should be done in the top level
+
+ // Rotate these into the right place for the stereo
+ // My rotations here are active rotations in the mother coordinate system frame
+ // Sloppy description of the frame
+ // u: direction along long edge of half module i.e. along strips
+ // v: normal to sensor plane
+ // w: perpendicular to the sensor
+
+ // flip around u
+ Rotation r1 = new Rotation(new Vector3D(1,0,0),Math.PI);
+ // apply stereo angle around v
+ Rotation r2 = new Rotation(new Vector3D(0,1,0),stereo_angle);
+ // Build full rotation
+ Rotation r = r2.applyTo(r1);
+ //Rotation r = r1;
+ if(debug) System.out.printf("%s: Coord before corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ if(debug) System.out.printf("%s: box center before corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ getCoord().rotateApache(r);
+ if(debug) System.out.printf("%s: Coord after corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ if(debug) System.out.printf("%s: box center after corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+
+
+ }
+
+
+ }
+
+ public static abstract class TestRunColdBlock extends SurveyVolume {
+ private int layer;
+ public TestRunColdBlock(String name, SurveyVolume mother, int layer) {
+ super(name, mother, null);
+ setLayer(layer);
+ init();
+ }
+ protected abstract double getWidth();
+ protected abstract double getLength();
+ protected abstract double getHeight();
+ public int getLayer() {
+ return layer;
+ }
+ public void setLayer(int layer) {
+ this.layer = layer;
+ }
+ protected void setCenter() {
+ setCenter(getLength()/2.0, 0.0, getWidth()/2.0);
+ }
+ protected void setPos() {
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ // cold block position w.r.t. module box coordinate system
+ // this is a dummy coordinate system, make it simple
+ // edge of cold block on the mounting surface
+ final double ball_pos_coldblock_local_x = -5.00;
+ final double ball_pos_coldblock_local_y = 0.00;
+ final double ball_pos_coldblock_local_z = 0.00;
+ final double vee_pos_coldblock_local_x = ball_pos_coldblock_local_x + 1.0; //arbitrary distance
+ final double vee_pos_coldblock_local_y = ball_pos_coldblock_local_y;
+ final double vee_pos_coldblock_local_z = ball_pos_coldblock_local_z;
+ final double flat_pos_coldblock_local_x = ball_pos_coldblock_local_x;
+ final double flat_pos_coldblock_local_y = ball_pos_coldblock_local_y + 1.0; //arbitrary distance
+ final double flat_pos_coldblock_local_z = ball_pos_coldblock_local_z;
+ setBallPos(ball_pos_coldblock_local_x, ball_pos_coldblock_local_y, ball_pos_coldblock_local_z);
+ setVeePos(vee_pos_coldblock_local_x, vee_pos_coldblock_local_y,vee_pos_coldblock_local_z);
+ setFlatPos(flat_pos_coldblock_local_x, flat_pos_coldblock_local_y,flat_pos_coldblock_local_z);
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ }
+ protected void setBoxDim() {
+ setBoxDim(getLength(), getHeight(), getWidth());
+ }
+ }
+
+ public static class TestRunColdBlockL13 extends TestRunColdBlock {
+ protected static final double coldblock_L13_length = 82.00;
+ protected static final double coldblock_L13_width = 52.50;
+ protected static final double coldblock_L13_thickness = 6.00;
+
+ public TestRunColdBlockL13(String name, SurveyVolume mother, int layer) {
+ super(name, mother, layer);
+ }
+ protected double getWidth() {
+ return coldblock_L13_width;
+ }
+ protected double getLength() {
+ return coldblock_L13_length;
+ }
+ protected double getHeight() {
+ return coldblock_L13_thickness;
+ }
+ protected double getThickness() {
+ return getHeight();
+ }
+ }
+
+ public static class TestRunColdBlockL45 extends TestRunColdBlock {
+ protected static final double coldblock_L45_length = 82.00;
+ protected static final double coldblock_L45_width = 51.00;
+ protected static final double coldblock_L45_thickness = 6.00;
+
+ public TestRunColdBlockL45(String name, SurveyVolume mother, int layer) {
+ super(name, mother, layer);
+ }
+ protected double getWidth() {
+ return coldblock_L45_width;
+ }
+ protected double getLength() {
+ return coldblock_L45_length;
+ }
+ protected double getHeight() {
+ return coldblock_L45_thickness;
+ }
+ protected double getThickness() {
+ return getHeight();
+ }
+ }
+
+
+ /**
+ * Silicon sensor @SurveyVolume.
+ * The coordinate system is located at the same position and orientation as the half-module.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class Sensor extends HalfModuleComponent {
+ static final double length= 100.00;
+ static final double width = 40.34;
+ static final double thickness = 0.32;
+ static final double height = thickness;
+ public Sensor(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, int id) {
+ super(name, mother, alignmentCorrection, id);
+ init();
+ }
+ public static double getSensorThickness() {
+ return height;
+ }
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ setBallPos(0,0,0);
+ setVeePos(ballPos.x() + width/2.0, ballPos.y(), ballPos.z());
+ setFlatPos(ballPos.x(),ballPos.y() + length/2.0, ballPos.z());
+
+// if(useSiStripsConvention) {
+// setBallPos(0,0,0);
+// setVeePos(ballPos.x(), ballPos.y(), ballPos.z() + getSensorWidth()/2.0);
+// setFlatPos(ballPos.x() + getSensorLength()/2.0,ballPos.y(), ballPos.z());
+// } else {
+// setBallPos(0,0,0);
+// setVeePos(ballPos.x() + getSensorLength()/2.0, ballPos.y(), ballPos.z());
+// setFlatPos(ballPos.x(),ballPos.y() + getSensorThickness()/2.0, ballPos.z());
+// }
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ }
+ protected void setCenter() {
+ setCenter(0,0,0);
+ }
+ protected void setBoxDim() {
+ if(useSiStripsConvention) {
+ setBoxDim(width,length,thickness);
+ } else {
+ setBoxDim(length,thickness,width);
+ }
+ }
+ protected double getThickness() {
+ return thickness;
+ }
+ protected double getHeigth() {
+ return thickness;
+ }
+ protected double getWidth() {
+ return width;
+ }
+ protected double getLength() {
+ return length;
+ }
+ }
+
+ /**
+ * Active part of the @Sensor @SurveyVolume.
+ * The coordinate system is located at the same position and orientation as the sensor.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class ActiveSensor extends SurveyVolume {
+ private static final double length= 98.33;
+ private static final double width = 38.3399;
+ private static final double thickness = Sensor.thickness;
+ public ActiveSensor(String name, SurveyVolume m) {
+ super(name, m, null);
+ init();
+ }
+ public static double getActiveSensorLength() {
+ return length;
+ }
+ public static double getActiveSensorWidth() {
+ return width;
+ }
+ public static double getActiveSensorHeight() {
+ return thickness;
+ }
+ public static double getActiveSensorThickness() {
+ return getActiveSensorHeight();
+ }
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ ballPos = new BasicHep3Vector(0,0,0);
+ veePos = new BasicHep3Vector(getActiveSensorWidth()/2.0,0,0);
+ flatPos = new BasicHep3Vector(0,getActiveSensorLength()/2.0,0);
+
+// if(useSiStripsConvention) {
+// ballPos = new BasicHep3Vector(0,0,0);
+// veePos = new BasicHep3Vector(getActiveSensorWidth()/2.0,0,0);
+// flatPos = new BasicHep3Vector(0,getActiveSensorLength()/2.0,0);
+// } else {
+// ballPos = new BasicHep3Vector(0,0,0);
+// veePos = new BasicHep3Vector(getActiveSensorWidth()/2.0,0,0);
+// flatPos = new BasicHep3Vector(0,getActiveSensorLength()/2.0,0);
+// }
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ setCenter(0,0,0);
+ }
+ protected void setBoxDim() {
+
+ setBoxDim(getActiveSensorWidth(), getActiveSensorLength(), getActiveSensorThickness());
+
+// if(useSiStripsConvention) {
+// setBoxDim(getActiveSensorWidth(), getActiveSensorLength(), getActiveSensorThickness());
+// } else {
+// setBoxDim(getActiveSensorLength(),getActiveSensorThickness(),getActiveSensorWidth());
+// }
+ }
+ }
+
+
+ /**
+ * Kapton insulation @SurveyVolume for the half-module
+ * The coordinate system is located at the same position and orientation as the sensor.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class HalfModuleLamination extends HalfModuleComponent {
+ protected static final double length = 184.0;
+ protected static final double width = 40.0; // -2.0; // width under the sensor, 2mm wider under hybrid.
+ protected static final double thickness = 0.050;
+ public HalfModuleLamination(String name, SurveyVolume m, int id) {
+ super(name, m, null, id);
+ init();
+ }
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+ // double ball_pos_kapton_local_x = -1 * (180.0 - Sensor.getSensorLength()/2.0) + 8.5;
+ // double ball_pos_kapton_local_y = (Sensor.getSensorThickness()/2.0 + HalfModuleLamination.kapton_thickness/2.0);
+ // double ball_pos_kapton_local_z = -1 * (Sensor.width/2.0 + 12.66) + 8.83 - 3.00 + 6.00 ;
+ // double vee_pos_kapton_local_x = ball_pos_kapton_local_x + 1.0; // arbitrary distance
+ // double vee_pos_kapton_local_y = ball_pos_kapton_local_y;
+ // double vee_pos_kapton_local_z = ball_pos_kapton_local_z;
+ // double flat_pos_kapton_local_x = ball_pos_kapton_local_x;
+ // double flat_pos_kapton_local_y = ball_pos_kapton_local_y + HalfModuleLamination.kapton_thickness/2.0; // arbitrary distance
+ // double flat_pos_kapton_local_z = ball_pos_kapton_local_z;
+
+// double ball_pos_kapton_local_x = -1 * (Sensor.width/2.0 + 12.66) + 8.83 - 3.00 + 6.00;
+// double ball_pos_kapton_local_y = -1 * (180.0 - Sensor.getSensorLength()/2.0) + 8.5;
+// double ball_pos_kapton_local_z = (Sensor.getSensorThickness()/2.0 + HalfModuleLamination.kapton_thickness/2.0);
+// double vee_pos_kapton_local_x = ball_pos_kapton_local_x + Sensor.width/2.0; // arbitrary distance
+// double vee_pos_kapton_local_y = ball_pos_kapton_local_y;
+// double vee_pos_kapton_local_z = ball_pos_kapton_local_z;
+// double flat_pos_kapton_local_x = ball_pos_kapton_local_x;
+// double flat_pos_kapton_local_y = ball_pos_kapton_local_y + Sensor.getSensorLength(); // arbitrary distance
+// double flat_pos_kapton_local_z = ball_pos_kapton_local_z;
+
+ double ball_pos_kapton_local_x = Sensor.width/2.0 + 6.83 - 6.0 - width/2.0;
+ double ball_pos_kapton_local_y = Sensor.length/2.0 - 170.0 - 10.0 + 8.5 + length/2.0;
+ double ball_pos_kapton_local_z = -1.0 * (Sensor.getSensorThickness()/2.0 + HalfModuleLamination.thickness/2.0);
+
+ //ballPos = new BasicHep3Vector(ball_pos_kapton_local_x,ball_pos_kapton_local_y,ball_pos_kapton_local_z);
+ //veePos = new BasicHep3Vector(vee_pos_kapton_local_x,vee_pos_kapton_local_y,vee_pos_kapton_local_z);
+ //flatPos = new BasicHep3Vector(flat_pos_kapton_local_x,flat_pos_kapton_local_y,flat_pos_kapton_local_z);
+
+ ballPos = new BasicHep3Vector(ball_pos_kapton_local_x,ball_pos_kapton_local_y,ball_pos_kapton_local_z);
+ veePos = new BasicHep3Vector(ballPos.x() + 1.0,ballPos.y(),ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(),ballPos.y()+ 1.0,ballPos.z());
+
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ setCenter(0.0, 0.0, 0.0);
+ //setCenter(getWidth()/2.0, getLength()/2.0,0.0);
+ //setCenter(getWidth()/2.0, getLength()/2.0,0.0);
+ }
+ protected double getThickness() {
+ return thickness;
+ }
+ protected double getHeigth() {
+ return getThickness();
+ }
+ protected double getWidth() {
+ return width;
+ }
+ protected double getLength() {
+ return length;
+ }
+ protected void setBoxDim() {
+ setBoxDim(getWidth(),getLength(),getThickness());
+ //setBoxDim(getLength(),getThickness(),getWidth());
+ }
+ }
+
+ /**
+ * Carbon fiber backing @SurveyVolume for the half-module
+ * The coordinate system is located at the same position and orientation as the sensor.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class CarbonFiber extends HalfModuleComponent {
+ protected static final double length = 200.;
+ protected static final double width = 45.;
+ protected static final double thickness = 0.250;
+ public CarbonFiber(String name, SurveyVolume m, int id) {
+ super(name, m, null, id);
+ init();
+ }
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+// final double ball_pos_cf_local_x = -1 * (180.0 - Sensor.getSensorLength()/2.0);
+// final double ball_pos_cf_local_y = (Sensor.getSensorThickness()/2.0 + HalfModuleLamination.kapton_thickness + TestRunHalfModule.getCFThickness()/2.0);
+// final double ball_pos_cf_local_z = -1 * (Sensor.width/2.0 + 12.66) + 8.83 - 3.00;
+// final double vee_pos_cf_local_x = ball_pos_cf_local_x + 1.0; // arbitrary distance
+// final double vee_pos_cf_local_y = ball_pos_cf_local_y;
+// final double vee_pos_cf_local_z = ball_pos_cf_local_z;
+// final double flat_pos_cf_local_x = ball_pos_cf_local_x;
+// final double flat_pos_cf_local_y = ball_pos_cf_local_y + TestRunHalfModule.getCFThickness()/2.0; // arbitrary distance
+// final double flat_pos_cf_local_z = ball_pos_cf_local_z;
+// setBallPos(ball_pos_cf_local_x,ball_pos_cf_local_y,ball_pos_cf_local_z);
+// setVeePos(vee_pos_cf_local_x,vee_pos_cf_local_y,vee_pos_cf_local_z);
+// setFlatPos(flat_pos_cf_local_x,flat_pos_cf_local_y,flat_pos_cf_local_z);
+
+// final double ball_pos_cf_local_x = -1 * (Sensor.width/2.0 + 12.66) + 8.83 - 3.00;
+// final double ball_pos_cf_local_y = -1 * (180.0 - Sensor.getSensorLength()/2.0);
+// final double ball_pos_cf_local_z = (Sensor.getSensorThickness()/2.0 + HalfModuleLamination.kapton_thickness + TestRunHalfModule.getCFThickness()/2.0);
+// final double vee_pos_cf_local_x = ball_pos_cf_local_x + Sensor.width/2.0; // arbitrary distance
+// final double vee_pos_cf_local_y = ball_pos_cf_local_y;
+// final double vee_pos_cf_local_z = ball_pos_cf_local_z;
+// final double flat_pos_cf_local_x = ball_pos_cf_local_x;
+// final double flat_pos_cf_local_y = ball_pos_cf_local_y + Sensor.getSensorLength()/2.0; // arbitrary distance
+// final double flat_pos_cf_local_z = ball_pos_cf_local_z;
+// setBallPos(ball_pos_cf_local_x,ball_pos_cf_local_y,ball_pos_cf_local_z);
+// setVeePos(vee_pos_cf_local_x,vee_pos_cf_local_y,vee_pos_cf_local_z);
+// setFlatPos(flat_pos_cf_local_x,flat_pos_cf_local_y,flat_pos_cf_local_z);
+
+
+ final double ball_pos_cf_local_x = Sensor.width/2.0 + 6.83 - width/2.0;
+ final double ball_pos_cf_local_y = Sensor.length/2.0 - 170.0 - 10.0 + length/2.0;
+ final double ball_pos_cf_local_z = -1 * ( Sensor.getSensorThickness()/2.0 + HalfModuleLamination.thickness + TestRunHalfModule.getCFThickness()/2.0 );
+
+ ballPos = new BasicHep3Vector(ball_pos_cf_local_x, ball_pos_cf_local_y, ball_pos_cf_local_z);
+ veePos = new BasicHep3Vector(ballPos.x() + 1.0, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y() + 1.0, ballPos.z());
+
+
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+
+ }
+ protected void setCenter() {
+ setCenter(0.0, 0.0, 0.0);
+ //setCenter(getWidth()/2.0, getLength()/2.0, 0.0);
+ //setCenter(getLength()/2.0, 0.0, getWidth()/2.0);
+ }
+ protected double getThickness() {
+ return thickness;
+ }
+ protected double getWidth() {
+ return width;
+ }
+ protected double getLength() {
+ return length;
+ }
+ protected double getHeigth() {
+ return getThickness();
+ }
+ protected void setBoxDim() {
+ setBoxDim(getWidth(),getLength(),getThickness());
+ //setBoxDim(getLength(),getThickness(),getWidth());
+ }
+ }
+
+ /**
+ * Hybrid @SurveyVolume for the half-module
+ * The coordinate system is located at the same position and orientation as the sensor.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class Hybrid extends HalfModuleComponent {
+ protected static final double hybrid_length = 170.0 - Sensor.length; // sensor b-to-b with hybrid
+ protected static final double hybrid_width = Sensor.width;
+ protected static final double hybrid_thickness = 4.0/64.0*inch;
+ public Hybrid(String name, SurveyVolume m, int id) {
+ super(name, m, null, id);
+ init();
+ }
+ protected void setPos() {
+
+ if(debug) System.out.printf("%s: setPos for %s\n",this.getClass().getSimpleName(),getName());
+
+// final double ball_pos_hybrid_local_x = -1 * (170.0 - Sensor.getSensorLength()/2.0);
+// final double ball_pos_hybrid_local_y = (Sensor.getSensorThickness()/2.0 - TestRunHalfModule.getHybridThickness()/2.0);
+// final double ball_pos_hybrid_local_z = -1 * (Sensor.width/2.0);
+// final double vee_pos_hybrid_local_x = ball_pos_hybrid_local_x + 1.0; // arbitrary distance
+// final double vee_pos_hybrid_local_y = ball_pos_hybrid_local_y;
+// final double vee_pos_hybrid_local_z = ball_pos_hybrid_local_z;
+// final double flat_pos_hybrid_local_x = ball_pos_hybrid_local_x;
+// final double flat_pos_hybrid_local_y = ball_pos_hybrid_local_y + TestRunHalfModule.getHybridThickness()/2.0; // arbitrary distance
+// final double flat_pos_hybrid_local_z = ball_pos_hybrid_local_z;
+// setBallPos(ball_pos_hybrid_local_x,ball_pos_hybrid_local_y,ball_pos_hybrid_local_z);
+// setVeePos(vee_pos_hybrid_local_x,vee_pos_hybrid_local_y,vee_pos_hybrid_local_z);
+// setFlatPos(flat_pos_hybrid_local_x,flat_pos_hybrid_local_y,flat_pos_hybrid_local_z);
+
+// final double ball_pos_hybrid_local_x = -1 * (Sensor.width/2.0);
+// final double ball_pos_hybrid_local_y = -1 * (170.0 - Sensor.getSensorLength()/2.0);
+// final double ball_pos_hybrid_local_z = (Sensor.getSensorThickness()/2.0 - TestRunHalfModule.getHybridThickness()/2.0);
+// final double vee_pos_hybrid_local_x = ball_pos_hybrid_local_x + Sensor.width/2.0; // arbitrary distance
+// final double vee_pos_hybrid_local_y = ball_pos_hybrid_local_y;
+// final double vee_pos_hybrid_local_z = ball_pos_hybrid_local_z;
+// final double flat_pos_hybrid_local_x = ball_pos_hybrid_local_x;
+// final double flat_pos_hybrid_local_y = ball_pos_hybrid_local_y + Sensor.getSensorLength()/2.0; // arbitrary distance
+// final double flat_pos_hybrid_local_z = ball_pos_hybrid_local_z;
+// setBallPos(ball_pos_hybrid_local_x,ball_pos_hybrid_local_y,ball_pos_hybrid_local_z);
+// setVeePos(vee_pos_hybrid_local_x,vee_pos_hybrid_local_y,vee_pos_hybrid_local_z);
+// setFlatPos(flat_pos_hybrid_local_x,flat_pos_hybrid_local_y,flat_pos_hybrid_local_z);
+
+ final double ball_pos_hybrid_local_x = 0.0;
+ final double ball_pos_hybrid_local_y = Sensor.length/2.0 - 170.0 + hybrid_length/2.0;
+ final double ball_pos_hybrid_local_z = -1.0*Sensor.getSensorThickness()/2.0 + hybrid_thickness/2.0;
+
+ ballPos = new BasicHep3Vector(ball_pos_hybrid_local_x,ball_pos_hybrid_local_y, ball_pos_hybrid_local_z);
+ veePos = new BasicHep3Vector(ballPos.x() + 1.0, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y() + 1.0, ballPos.z());
+
+
+
+ if(debug) {
+ System.out.printf("%s: survey positions for %s\n",this.getClass().getSimpleName(),getName());
+ printSurveyPos();
+ }
+ }
+ protected void setCenter() {
+ setCenter(0.0, 0.0, 0.0);
+ //setCenter(getWidth()/2.0, getLength()/2.0, 0.0);
+ //setCenter(getLength()/2.0, 0.0, getWidth()/2.0);
+ }
+ protected double getThickness() {
+ return hybrid_thickness;
+ }
+ protected double getHeigth() {
+ return getThickness();
+ }
+ protected double getWidth() {
+ return hybrid_width;
+ }
+ protected double getLength() {
+ return hybrid_length;
+ }
+ protected void setBoxDim() {
+ setBoxDim(getWidth(), getLength(),getThickness());
+ //setBoxDim(getLength(),getThickness(), getWidth());
+ }
+ }
+
+
+ /**
+ * Base class for components of a half-module @SurveyVolume
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static abstract class HalfModuleComponent extends SurveyVolume {
+ int id = -1;
+ public HalfModuleComponent(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, int id) {
+ super(name, mother, alignmentCorrection);
+ this.id = id;
+ }
+ protected abstract double getThickness();
+ protected abstract double getHeigth();
+ protected abstract double getWidth();
+ protected abstract double getLength();
+ public int getId() {
+ return id;
+ }
+ }
+
+
+
+
+
+ public static class TestRunHalfModuleBundle extends HalfModuleBundle {
+ protected SurveyVolume carbonFiber = null;
+ protected SurveyVolume hybrid = null;
+ TestRunHalfModuleBundle(SurveyVolume hm) {
+ super(hm);
+ }
+ }
+
+
+ protected TestRunHalfModuleAxial createTestRunHalfModuleAxial(String volName,
+ BaseModule mother, AlignmentCorrection alignmentCorrection,
+ int layer, String half) {
+ return new TestRunHalfModuleAxial(volName, mother, alignmentCorrection, layer, half);
+
+ }
+
+
+ protected TestRunHalfModuleStereo createTestRunHalfModuleStereo(
+ String volName, BaseModule mother,
+ AlignmentCorrection alignmentCorrection, int layer, String half) {
+ return new TestRunHalfModuleStereo(volName, mother, alignmentCorrection, layer, half);
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition#getHalfModuleBundle(org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BaseModule, java.lang.String)
+ */
+ protected HalfModuleBundle getHalfModuleBundle(BaseModule module, String halfModuleName) {
+ BaseModuleBundle m = getModuleBundle(module.getLayer(), module.getHalf());
+ HalfModuleBundle hm = null;
+ // TODO this needs to change when I build quarter-modules for the long half-modules.
+ if(m!=null) {
+ if( m instanceof TestRunModuleBundle) {
+ TestRunModuleBundle mtr = (TestRunModuleBundle) m;
+ if(halfModuleName.contains("axial")) {
+ hm = mtr.halfModuleAxial;
+ }
+ else if(halfModuleName.contains("stereo")) {
+ hm = mtr.halfModuleStereo;
+ }
+ else {
+ throw new RuntimeException("No axial or stereo string found in half module bundle name " + halfModuleName);
+ }
+ }
+ else {
+ throw new RuntimeException("The type of this module bundle is incorrect. Should be a TestRunModuleBundle.");
+ }
+ } else {
+ throw new RuntimeException("No module found for " + module.getLayer() + " and half " + module.getHalf());
+ }
+ return hm;
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerBuilder#getOldGeomDefLayerFromVolumeName(java.lang.String)
+ */
+ public int getOldGeomDefLayerFromVolumeName(String name) {
+
+ String half = getHalfFromName(name);
+ int l = getLayerFromVolumeName(name);
+ boolean isTopLayer = false;
+ if(half=="top") isTopLayer=true;
+ else if(half=="bottom") isTopLayer = false;
+ else throw new RuntimeException("no half found from " + name);
+ boolean isAxial = isAxialFromName(name);
+ return getOldLayerDefinition(isTopLayer, l, isAxial);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerBuilder#getOldLayerDefinition(boolean, int, boolean)
+ */
+ public int getOldLayerDefinition(boolean isTopLayer, int l, boolean isAxial) {
+ int layer=-1;
+ if(isAxial) {
+ if(isTopLayer) {
+ layer = 2*l-1;
+ }
+ else {
+ layer = 2*l;
+ }
+ } else {
+ if(isTopLayer) {
+ layer = 2*l;
+ } else {
+ layer = 2*l-1;
+ }
+ }
+ return layer;
+ }
+
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerBuilder#getMillepedeLayer(java.lang.String)
+ */
+ public int getMillepedeLayer(String name) {
+ return getOldGeomDefLayerFromVolumeName(name);
+ }
+
+
+
+
+
+}
+
+
+
+
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014JavaBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014JavaBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014JavaBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,213 @@
+/**
+ *
+ */
+package org.lcsim.geometry.compact.converter;
+
+import java.util.ArrayList;
+
+import org.jdom.Element;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BasePlate;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.Sensor;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportBottom;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportPlateBottom;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportPlateTop;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportTop;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.BaseModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TestRunModuleBundle;
+
+
+/**
+ * Class used by java converter to build java run time objects for the detector
+ * It encapsulates and adds the LCDD specific information to the generic @HPSTestRunTracker2014Builder.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTestRunTracker2014JavaBuilder extends HPSTrackerJavaBuilder {
+
+
+
+ /**
+ * Default constructor
+ * @param node
+ */
+ public HPSTestRunTracker2014JavaBuilder(boolean debugFlag, Element node) {
+ super(debugFlag, node);
+ }
+
+
+
+ /**
+ * Build the JAVA geometry objects from the geometry definition.
+ * @param trackingVolume - the reference volume.
+ */
+ public void build(ILogicalVolume trackingVolume) {
+
+ // build geometry
+ setBuilder(createGeometryDefinition(_debug, node));
+
+ if(_builder==null) throw new RuntimeException("need to set builder class before calling build!");
+
+ if(isDebug()) System.out.printf("%s: build the base geometry objects\n", getClass().getSimpleName());
+
+ _builder.build();
+
+ if(isDebug()) System.out.printf("%s: DONE build the base geometry objects\n", getClass().getSimpleName());
+
+ if(isDebug()) System.out.printf("%s: build the JAVA geometry objects\n", getClass().getSimpleName());
+
+ // initialize the list to store a reference to each object
+ javaSurveyVolumes = new ArrayList<JavaSurveyVolume>();
+
+ // Go through the list of volumes to build that is created in the generic builder class
+ JavaSurveyVolume trackingGeometry = new JavaSurveyVolume(_builder.getSurveyVolume(org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TrackingVolume.class), trackingVolume);
+ add(trackingGeometry);
+ //setBaseTrackerGeometry(new GhostJavaBaseGeom(_builder.getBaseGeometry(Base.class), trackingGeometry));
+ setBaseTrackerGeometry(new JavaSurveyVolume(_builder.getSurveyVolume(TrackerEnvelope.class), trackingGeometry,1));
+ add(getBaseTrackerGeometry());
+ JavaSurveyVolume basePlateGeometry = new JavaGhostSurveyVolume(_builder.getSurveyVolume(BasePlate.class), getBaseTrackerGeometry());
+ add(basePlateGeometry);
+ // skip the c-support, this is purely a reference volume in the builder so should have no use here!?
+ //JavaBaseGeometry cSupportGeometry = new GhostJavaBaseGeom(_builder.getBaseGeometry(CSupport.class), baseTrackerGeometry);
+ //add(cSupportGeometry);
+ JavaSurveyVolume supportBottomGeometry = new JavaGhostSurveyVolume(_builder.getSurveyVolume(SupportBottom.class), getBaseTrackerGeometry());
+ add(supportBottomGeometry);
+ JavaSurveyVolume supportPlateBottomGeometry = new JavaGhostSurveyVolume(_builder.getSurveyVolume(SupportPlateBottom.class), getBaseTrackerGeometry());
+ add(supportPlateBottomGeometry);
+ JavaSurveyVolume supportTopGeometry = new JavaGhostSurveyVolume(_builder.getSurveyVolume(SupportTop.class), getBaseTrackerGeometry());
+ add(supportTopGeometry);
+ JavaSurveyVolume supportPlateTopGeometry = new JavaGhostSurveyVolume(_builder.getSurveyVolume(SupportPlateTop.class), getBaseTrackerGeometry());
+ add(supportPlateTopGeometry);
+
+ // build modules
+
+ if(isDebug()) System.out.printf("%s: build JAVA modules\n", getClass().getSimpleName());
+
+ // Loop over all modules created
+ for(BaseModuleBundle mod : _builder.modules) {
+ TestRunModuleBundle m = (TestRunModuleBundle) mod;
+ if(isDebug()) {
+ System.out.printf("%s: build module %s (layer %d half %s)\n", getClass().getSimpleName(),m.module.getName(),m.getLayer(),m.getHalf());
+ m.print();
+ }
+
+ // Find the mother among the objects using its name, should probably have a better way...
+ String name_mother = m.getMother().getName();
+ JavaSurveyVolume mother = null;
+ for(JavaSurveyVolume g : javaSurveyVolumes) {
+ if(g.getName().equals(name_mother)) {
+ mother = g;
+ break;
+ }
+ }
+ // Check that it had a mother
+ if(mother==null) throw new RuntimeException("Cound't find mother to module " + m.module.getName());
+
+ if(isDebug()) System.out.printf("%s: found mother %s to module %s\n", getClass().getSimpleName(),mother.getName(),m.module.getName());
+
+ // put the module in the list of objects that will be added to LCDD
+ addTestRunModule(m, mother);
+
+ if(isDebug()) System.out.printf("%s: DONE build module %s\n", getClass().getSimpleName(), m.module.getName());
+
+
+ }
+
+ if(isDebug()) System.out.printf("%s: DONE build JAVA modules\n", getClass().getSimpleName());
+
+
+ if(isDebug()) System.out.printf("%s: DONE building the JAVA geometry objects\n", getClass().getSimpleName());
+ if(isDebug()) {
+ System.out.printf("%s: DONE building the JAVA geometry objects\n", getClass().getSimpleName());
+ System.out.printf("%s: List of all the JAVA geometry objects built\n", this.getClass().getSimpleName());
+ for(JavaSurveyVolume bg : javaSurveyVolumes) {
+ System.out.printf("-------\n%s\n", bg.toString());
+ }
+ }
+
+
+ // Set visualization features
+ //setVis();
+
+
+ }
+
+ /**
+ * Rules for adding the JAVA module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother JAVA geometry object
+ */
+ protected void addTestRunModule(TestRunModuleBundle bundle, JavaSurveyVolume mother) {
+
+ if(isDebug()) {
+ System.out.printf("%s: addModule %s containing:\n",this.getClass().getSimpleName(), bundle.module.getName());
+ bundle.print();
+ }
+
+ // Create the module
+ JavaSurveyVolume lcddM = new JavaGhostSurveyVolume(bundle.module, mother);
+ add(lcddM);
+
+ // add half modules
+ if(bundle.halfModuleAxial!=null) addHalfModule((TestRunHalfModuleBundle)bundle.halfModuleAxial,lcddM);
+ if(bundle.halfModuleStereo!=null) addHalfModule((TestRunHalfModuleBundle)bundle.halfModuleStereo,lcddM);
+
+
+ if(isDebug()) {
+ System.out.printf("%s: DONE addModule %s \n",this.getClass().getSimpleName(), bundle.module.getName());
+ }
+
+ }
+
+
+ /**
+ * Rules for adding the JAVA half module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother JAVA geometry object
+ */
+ private void addHalfModule(TestRunHalfModuleBundle bundle, JavaSurveyVolume mother) {
+ // Create the half-module
+ // This is not a ghost element but reflects the module
+ // concept in the old compact description
+ // TODO fix the layer IDs
+ int oldCompactModuleId = 0;
+ JavaSurveyVolume lcddHM = new JavaSurveyVolume(bundle.halfModule, mother,oldCompactModuleId);
+ add(lcddHM);
+
+ // ComponentNumber is taken from old geometry where it is simply a counter when adding the xml daughters to the TestRunModule.
+ // It is simply 0 for sensor and 1 for carbon fiber in the old geometry
+ int componentNumber = ((Sensor)bundle.sensor).getId();
+
+ // create the sensor
+ JavaSurveyVolume lcddS = new JavaSurveyVolume(bundle.sensor, lcddHM, componentNumber);
+ add(lcddS);
+
+ // create the active sensor
+ JavaSurveyVolume lcddAS = new JavaSurveyVolume(bundle.activeSensor, lcddS, componentNumber);
+ add(lcddAS);
+
+// if(isDebug()) {
+// System.out.printf("%s: added sensor %s \n",this.getClass().getSimpleName(), lcddS.getName());
+// System.out.printf("%s: local coordinate system\n%s\n",this.getClass().getSimpleName(), bundle.sensor.getCoord().toString());
+// dsd
+// }
+
+
+ }
+
+
+
+ @Override
+ public HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug, Element node) {
+ return new HPSTestRunTracker2014GeometryDefinition(debug, node);
+ }
+
+
+
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014LCDDBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014LCDDBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTestRunTracker2014LCDDBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,182 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BasePlate;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.CSupport;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportBottom;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportPlateBottom;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportPlateTop;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.SupportTop;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.BaseModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.HalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TestRunModuleBundle;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+
+
+/**
+ * Class used by LCDD converter to build detector for SLIC.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTestRunTracker2014LCDDBuilder extends HPSTrackerLCDDBuilder {
+
+
+ public HPSTestRunTracker2014LCDDBuilder(boolean debugFlag, Element node, LCDD lcdd, SensitiveDetector sens) {
+ super(debugFlag, node, lcdd, sens);
+ }
+
+
+ public void setBuilder() {
+ setBuilder();
+ }
+
+ public void build(Volume worldVolume) {
+
+ // set and build geometry
+ setBuilder(createGeometryDefinition(_debug, node));
+
+ if(_builder==null) throw new RuntimeException("need to set builder class before calling build!");
+
+ if(isDebug()) System.out.printf("%s: build the base geometry objects\n", getClass().getSimpleName());
+
+ _builder.build();
+
+ if(isDebug()) System.out.printf("%s: DONE build the base geometry objects\n", getClass().getSimpleName());
+
+
+ if(isDebug()) System.out.printf("%s: build the LCDD geometry objects\n", getClass().getSimpleName());
+
+
+ // Go through the list of volumes to build that is created in the generic builder class
+ // TODO this is manual now since I don't have a way of knowing in the generic builder class what is a ghost volume at this point.
+ LCDDSurveyVolume trackingGeometry = new LCDDSurveyVolume(_builder.getSurveyVolume(org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TrackingVolume.class), worldVolume);
+ add(trackingGeometry);
+ baseSurveyVolume = new LCDDSurveyVolume(_builder.getSurveyVolume(TrackerEnvelope.class), lcdd, trackingGeometry);
+ add(baseSurveyVolume);
+ LCDDSurveyVolume basePlateGeometry = new LCDDSurveyVolume(_builder.getSurveyVolume(BasePlate.class), lcdd, baseSurveyVolume);
+ add(basePlateGeometry);
+ // TODO I don't think this c-support has any use at all since the coordinates of it has been already used in the builder. Should remove?
+ LCDDSurveyVolume cSupportGeometry = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(CSupport.class), baseSurveyVolume);
+ add(cSupportGeometry);
+ LCDDSurveyVolume supportBottomGeometry = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(SupportBottom.class), baseSurveyVolume);
+ add(supportBottomGeometry);
+ LCDDSurveyVolume supportPlateBottomGeometry = new LCDDSurveyVolume(_builder.getSurveyVolume(SupportPlateBottom.class), lcdd, baseSurveyVolume);
+ add(supportPlateBottomGeometry);
+ LCDDSurveyVolume supportTopGeometry = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(SupportTop.class), baseSurveyVolume);
+ add(supportTopGeometry);
+ LCDDSurveyVolume supportPlateTopGeometry = new LCDDSurveyVolume(_builder.getSurveyVolume(SupportPlateTop.class), lcdd, baseSurveyVolume);
+ add(supportPlateTopGeometry);
+
+ // build modules
+
+ if(isDebug()) System.out.printf("%s: build modules\n", getClass().getSimpleName());
+
+ // Loop over all modules created
+ for(BaseModuleBundle mod : _builder.modules) {
+ TestRunModuleBundle m = (TestRunModuleBundle) mod;
+ if(isDebug()) {
+ System.out.printf("%s: module layer %d half %s\n", getClass().getSimpleName(),m.getLayer(),m.getHalf());
+ m.print();
+ }
+
+ // Find the mother among the LCDD objects using its name, should probably have a better way...
+ String name_mother = m.getMother().getName();
+ LCDDSurveyVolume mother = null;
+ for(LCDDSurveyVolume g : lcddSurveyVolumes) {
+ if(g.getName().equals(name_mother)) {
+ mother = g;
+ break;
+ }
+ }
+ // Check that it had a mother
+ if(mother==null) throw new RuntimeException("Cound't find mother to module layer " + m.getLayer() + " half "+ m.getHalf());
+
+ if(isDebug()) System.out.printf("%s: found mother %s for module layer %d half %s\n", getClass().getSimpleName(),mother.getName(),m.getLayer(),m.getHalf());
+
+ // add the module to the list of objects that will be added to LCDD
+ addTestRunModule(m, mother);
+
+ }
+
+
+
+ if(isDebug()) {
+ System.out.printf("%s: DONE building the LCDD geometry objects\n", getClass().getSimpleName());
+ System.out.printf("%s: List of all %d LCDD geometry objects built\n", this.getClass().getSimpleName(), lcddSurveyVolumes.size());
+ for(SurveyVolumeImpl bg : lcddSurveyVolumes) {
+ System.out.printf("-------\n%s\n", bg.toString());
+ }
+ }
+
+
+
+ // Set visualization features
+ setVisualization();
+
+
+ }
+
+
+ /**
+ * Rules for adding the LCDD module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ protected void addTestRunModule(TestRunModuleBundle bundle, LCDDSurveyVolume mother) {
+ // This could perhaps be fixed if there is a relation with daughters in geometry definition?
+ // create the module
+ LCDDSurveyVolume lcddM = new LCDDSurveyVolume(bundle.module, lcdd, mother);
+ add(lcddM);
+ if(bundle.halfModuleAxial!=null) addTestRunHalfModule(bundle.halfModuleAxial,lcddM);
+ if(bundle.coldBlock!=null) add(new LCDDSurveyVolume(bundle.coldBlock, lcdd, lcddM));
+ if(bundle.halfModuleStereo!=null) addTestRunHalfModule((TestRunHalfModuleBundle)bundle.halfModuleStereo,lcddM);
+// if(bundle.halfModuleAxial!=null) addHalfModule((TestRunHalfModuleBundle)bundle.halfModuleAxial,lcddM);
+// if(bundle.coldBlock!=null) add(new LCDDSurveyVolume(bundle.coldBlock, lcdd, lcddM));
+// if(bundle.halfModuleStereo!=null) addHalfModule((TestRunHalfModuleBundle)bundle.halfModuleStereo,lcddM);
+
+ }
+
+ /**
+ * Rules for adding the LCDD half module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ protected void addTestRunHalfModule(HalfModuleBundle bundle2, LCDDSurveyVolume mother) {
+ // This could perhaps be fixed if there is a relation with daughters in geometry definition?
+ TestRunHalfModuleBundle bundle = (TestRunHalfModuleBundle) bundle2;
+
+ // create the half-module
+ LCDDSurveyVolume lcddHM = new LCDDSurveyVolume(bundle.halfModule, lcdd, mother);
+ add(lcddHM);
+ // create the sensor
+ LCDDSurveyVolume lcddS = new LCDDSurveyVolume(bundle.sensor, lcdd, lcddHM);
+ add(lcddS);
+ // create the active sensor
+ LCDDSurveyVolume lcddAS = new LCDDSurveyVolume(bundle.activeSensor, lcdd, lcddS);
+ add(lcddAS);
+ // create the lamination
+ LCDDSurveyVolume lcddL = new LCDDSurveyVolume(bundle.lamination, lcdd, lcddHM);
+ add(lcddL);
+ // create the carbon fiber frame
+ LCDDSurveyVolume lcddCF = new LCDDSurveyVolume(bundle.carbonFiber, lcdd, lcddHM);
+ add(lcddCF);
+ // create the hybrid frame
+ LCDDSurveyVolume lcddH = new LCDDSurveyVolume(bundle.hybrid, lcdd, lcddHM);
+ add(lcddH);
+
+ }
+
+
+ @Override
+ public HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug,
+ Element node) {
+ return new HPSTestRunTracker2014GeometryDefinition(_debug, node);
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014GeometryDefinition.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014GeometryDefinition.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014GeometryDefinition.java Tue May 5 14:05:24 2015
@@ -0,0 +1,2396 @@
+/**
+ *
+ */
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.VecOp;
+
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BaseModule;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.CarbonFiber;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.Sensor;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule;
+
+
+/**
+ *
+ * Geometry information for the HPS tracker 2014
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public class HPSTracker2014GeometryDefinition extends HPSTrackerGeometryDefinition {
+
+
+
+ public HPSTracker2014GeometryDefinition(boolean debug, Element node) {
+ super(debug, node);
+ doAxial = true;
+ doStereo = true;
+ doColdBlock = false;
+ doBottom = true;
+ doTop = true;
+ layerBitMask = 0x3F;
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerBuilder#build()
+ */
+ public void build() {
+
+ if(isDebug()) System.out.printf("%s: constructing the geometry objects\n", this.getClass().getSimpleName());
+
+ // Build the geometry from the basic building blocks in the geometry definition class
+ // Keep the order correct.
+ // Each item has knowledge of its mother but not its daughters
+ HPSTrackerGeometryDefinition.TrackingVolume tracking = new HPSTrackerGeometryDefinition.TrackingVolume("trackingVolume",null);
+ surveyVolumes.add(tracking);
+
+ PSVacuumChamber chamber = new PSVacuumChamber("chamber", tracking, null);
+ surveyVolumes.add(chamber);
+
+ SvtBox svtBox = new SvtBox("base",chamber, null);
+ surveyVolumes.add(svtBox);
+
+ SvtBoxBasePlate svtBoxBasePlate = new SvtBoxBasePlate("base_plate",svtBox,null);
+ surveyVolumes.add(svtBoxBasePlate);
+
+ //SupportRing supportRing = new SupportRing("c_support", svtBox, null, svtBoxBasePlate);
+ //surveyVolumes.add(supportRing);
+
+// AlignmentCorrection supBotCorr = this.getSupportAlignmentCorrection(false);
+// SupportRingL13BottomKinMount supportRingKinL13Bottom = new SupportRingL13BottomKinMount("c_support_kin_L13b", svtBox, supBotCorr, supportRing);
+// surveyVolumes.add(supportRingKinL13Bottom);
+
+ AlignmentCorrection supBotCorr = this.getSupportAlignmentCorrection(false);
+ SupportRingL13BottomKinMount supportRingKinL13Bottom = new SupportRingL13BottomKinMount("c_support_kin_L13b", svtBox, supBotCorr);
+ surveyVolumes.add(supportRingKinL13Bottom);
+
+
+ UChannelL13 uChannelL13Bottom = new UChannelL13Bottom("support_bottom_L13", svtBox, null, supportRingKinL13Bottom);
+ surveyVolumes.add(uChannelL13Bottom);
+
+ UChannelL13Plate uChannelL13BottomPlate = new UChannelL13BottomPlate("support_plate_bottom_L13", svtBox, null, uChannelL13Bottom);
+ surveyVolumes.add(uChannelL13BottomPlate);
+
+// AlignmentCorrection supTopCorr = this.getSupportAlignmentCorrection(true);
+// SupportRingL13TopKinMount supportRingKinL13Top = new SupportRingL13TopKinMount("c_support_kin_L13t", svtBox, supTopCorr, supportRing);
+// surveyVolumes.add(supportRingKinL13Top);
+
+ AlignmentCorrection supTopCorr = this.getSupportAlignmentCorrection(true);
+ SupportRingL13TopKinMount supportRingKinL13Top = new SupportRingL13TopKinMount("c_support_kin_L13t", svtBox, supTopCorr);
+ surveyVolumes.add(supportRingKinL13Top);
+
+
+ UChannelL13Top uChannelL13Top = new UChannelL13Top("support_top_L13", svtBox, null, supportRingKinL13Top);
+ surveyVolumes.add(uChannelL13Top);
+
+ UChannelL13Plate uChannelL13TopPlate = new UChannelL13TopPlate("support_plate_top_L13", svtBox, null, uChannelL13Top);
+ surveyVolumes.add(uChannelL13TopPlate);
+
+ UChannelL46 uChannelL46Bottom = new UChannelL46Bottom("support_bottom_L46", svtBox, null);
+ surveyVolumes.add(uChannelL46Bottom);
+
+ UChannelL46Plate uChannelL46BottomPlate = new UChannelL46BottomPlate("support_plate_bottom_L46", svtBox, null, uChannelL46Bottom);
+ surveyVolumes.add(uChannelL46BottomPlate);
+
+ UChannelL46 uChannelL46Top = new UChannelL46Top("support_top_L46", svtBox, null);
+ surveyVolumes.add(uChannelL46Top);
+
+ UChannelL46Plate uChannelL46TopPlate = new UChannelL46TopPlate("support_plate_top_L46", svtBox, null, uChannelL46Top);
+ surveyVolumes.add(uChannelL46TopPlate);
+
+
+ for(int l=1; l<=6;++l) {
+ if(doLayer(l)) {
+ if(doBottom) makeModuleBundle(l,"bottom");
+ if(doTop) makeModuleBundle(l,"top");
+ }
+ }
+
+ System.out.printf("%s: Constructed %d geometry objects\n", this.getClass().getSimpleName(), surveyVolumes.size());
+ System.out.printf("%s: Constructed %d module bundles\n", this.getClass().getSimpleName(),modules.size());
+
+
+ if(isDebug()) {
+ System.out.printf("%s: DONE constructing the geometry objects\n", this.getClass().getSimpleName());
+ System.out.printf("%s: List of the survey volumes built\n", this.getClass().getSimpleName());
+ for(SurveyVolume bg : surveyVolumes) {
+ System.out.printf("-------\n%s\n", bg.toString());
+ }
+ System.out.printf("%s: List of the module bundles built\n", this.getClass().getSimpleName());
+ for(BaseModuleBundle bundle : this.modules) {
+ bundle.print();
+ }
+
+ }
+
+ }
+
+
+ /**
+ * @SurveyVolume volume defining the pair spectrometer (PS) vacuum chamber
+ * Reference: tracking volume coordinate system
+ * Origin: same as reference
+ * Orientation: u - points in x direction (towards positron side), v - points upstream
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class PSVacuumChamber extends SurveyVolume {
+ public static final double height = PS_vac_box_inner_height;
+ public static final double width = PS_vac_box_inner_width;
+ public static final double length = PS_vac_box_inner_length;
+
+
+
+ public PSVacuumChamber(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name, mother, alignmentCorrection);
+ init();
+ }
+
+ protected void setCenter() {
+ setCenter(0, 0, 0);
+ }
+ protected void setBoxDim() {
+ setBoxDim(width,length,height);
+ }
+ protected void setPos() {
+ ballPos = new BasicHep3Vector(SvtBox.center_to_target_x, SvtBox.center_to_target_y, SvtBox.center_to_target_z);
+ veePos = new BasicHep3Vector(ballPos.x() + 1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y(), ballPos.z()-1);
+
+ }
+ }
+
+
+ /**
+ * @SurveyVolume volume defining the SVT box envelope
+ * Reference: PS vacuum chamber coordinate system. Note that the PS vacuum chamber box is placed w.r.t. this box and the target positions.
+ * Origin: intersection of midplanes vertically and horizontally
+ * Orientation: same as reference
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class SvtBox extends SurveyVolume {
+ public static final double height = 6.740*inch;
+ public static final double width = SvtBoxBasePlate.width;
+ public static final double length = SvtBoxBasePlate.length;
+
+ // position of the target w.r.t. center of this box.
+ // the coordinate frame is the JLab coordinates..confusing.
+ public static final double center_to_target_z = 13.777*inch;
+ public static final double center_to_target_x = 0.84*inch;
+ public static final double center_to_target_y = 0.0;
+
+
+
+
+ public SvtBox(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name, mother, alignmentCorrection);
+ init();
+ }
+
+ protected void setCenter() {
+ setCenter(0,0,0);
+ }
+ protected void setBoxDim() {
+ setBoxDim(width,length,height);
+ }
+ protected void setPos() {
+
+ ballPos = new BasicHep3Vector(0, 0, 0);
+ veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()+1, ballPos.z());
+
+ }
+ }
+
+
+ /**
+ * @SurveyVolume volume defining the base plate of the SVT box.
+ * Reference: @SvtBox coordinate system.
+ * Origin: surface of base plate intersection with center of hole for adjustment screw on positron side
+ * Orientation: same as reference
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class SvtBoxBasePlate extends SurveyVolume {
+ public static final double length = 50.5*inch;
+ public static final double width = 16.0*inch;
+ public static final double height = 0.25*inch;
+ public static final double kin_mount_to_edge_of_plate_x = (8.0-5.0)*inch;
+ public static final double kin_mount_to_edge_of_plate_y = 0.375*inch;
+ public static final double adj_screw_height = 0.13*inch; // amount screw sticks out from plate
+ public static final double adj_screw_width = 0.13*inch; // amount screw sticks out on side
+
+
+ public SvtBoxBasePlate(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name, mother, alignmentCorrection);
+ setMaterial("Aluminum");
+ init();
+ }
+
+ protected void setCenter() {
+ final double x = -kin_mount_to_edge_of_plate_x + SvtBoxBasePlate.width/2.0;
+ final double y = -kin_mount_to_edge_of_plate_y + SvtBoxBasePlate.length/2.0;
+ final double z = -SvtBoxBasePlate.height/2.0;
+ setCenter(new BasicHep3Vector(x, y, z));
+ }
+ protected void setBoxDim() {
+ setBoxDim(width, length, height);
+ }
+ protected void setPos() {
+ final double x = -width/2.0 + kin_mount_to_edge_of_plate_x;
+ final double y = -length/2.0 + kin_mount_to_edge_of_plate_y;
+ final double z = -SvtBox.height/2.0 + height;
+ ballPos = new BasicHep3Vector(x, y, z);
+ veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()+1, ballPos.z());
+ }
+
+ }
+
+
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the support ring
+ * Reference: @SvtBoxBasePlate
+ * Origin: pin position of support ring (electron side)
+ * Orientation: slot position is vee position (positron side) i.e u points towards the positron side and v in the upstream beam direction
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class SupportRing extends SurveyVolume {
+ private static final double plateThickness = 0.35*inch;
+
+ public SupportRing(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+ protected void setCenter() {
+ setCenter(null); //dummy
+ }
+ protected void setBoxDim() {
+ // do nothing
+ }
+ protected void setPos() {
+
+ final double ball_pos_x = -SvtBoxBasePlate.kin_mount_to_edge_of_plate_x + SvtBoxBasePlate.width/2.0 - 6.997*inch;
+ final double ball_pos_y = -SvtBoxBasePlate.kin_mount_to_edge_of_plate_y + SvtBoxBasePlate.length -28.543*inch;
+ final double ball_pos_z = 0.0;
+
+
+ final double vee_pos_x = -SvtBoxBasePlate.kin_mount_to_edge_of_plate_x + SvtBoxBasePlate.width/2.0 + 6.622*inch;
+ final double vee_pos_y = -SvtBoxBasePlate.kin_mount_to_edge_of_plate_y + SvtBoxBasePlate.length - 28.116*inch;
+ final double vee_pos_z = 0.0;
+
+
+ ballPos = new BasicHep3Vector(ball_pos_x, ball_pos_y, ball_pos_z);
+ veePos = new BasicHep3Vector(vee_pos_x, vee_pos_y, vee_pos_z);
+ flatPos = new BasicHep3Vector(0,0,0);
+
+ Hep3Vector uPrime = VecOp.unit(VecOp.sub(veePos, ballPos));
+ Rotation r = new Rotation(new Vector3D(1,0,0),new Vector3D(0,0,1), new Vector3D(uPrime.v()), new Vector3D(0,0,1));
+ Hep3Vector vPrime = new BasicHep3Vector(r.applyTo(new Vector3D(0, 1, 0)).toArray());
+ flatPos = VecOp.add(ballPos, vPrime);
+ }
+ }
+
+
+
+ /**
+ * Abstract @SurveyVolume volume defining a coordinate system from the kinematic mount positions for support channels
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class SupportRingL13KinMount extends SurveyVolume {
+
+ public static final double kin_mount_offset_vertically = 0.093*inch;
+ protected static final double kin_mount_pos_x = -138.665;
+ protected static final double kin_mount_pos_y = -67.855;
+
+ public SupportRingL13KinMount(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name, mother, alignmentCorrection);
+ }
+ protected void setCenter() {
+ setCenter(null); //dummy
+ }
+ protected void setBoxDim() {
+ // do nothing
+ }
+ protected void setPos() {
+ ballPos = new BasicHep3Vector(kin_mount_pos_x, kin_mount_pos_y, getKinMountVerticalPos());
+
+ final double vee_pos_x = ballPos.x()+1; // random positive offset
+ final double vee_pos_y = ballPos.y();
+ final double vee_pos_z = ballPos.z();
+ veePos = new BasicHep3Vector(vee_pos_x, vee_pos_y, vee_pos_z);
+
+ final double flat_pos_x = ballPos.x();
+ final double flat_pos_y = ballPos.y() + 1.0; // random positive offset
+ final double flat_pos_z = ballPos.z();
+ flatPos = new BasicHep3Vector(flat_pos_x,flat_pos_y,flat_pos_z);
+ }
+ abstract protected double getKinMountVerticalPos();
+ }
+
+ /**
+ * @SurveyVolume volume defining a coordinate system from the kinematic mount positions for support channels
+ * Reference: {@SvtBox} coordinate system
+ * Origin: cone mount (it's on the electron side)
+ * Orientation: ball is cone mount, slot mount is vee position and flat is along beamline pointing upstream
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class SupportRingL13BottomKinMount extends SupportRingL13KinMount {
+
+ protected static final double kin_mount_pos_z = -67.996;
+
+ public SupportRingL13BottomKinMount(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name, mother, alignmentCorrection);
+ init();
+ }
+
+ @Override
+ protected double getKinMountVerticalPos() {
+ return kin_mount_pos_z;
+ }
+
+// protected void setPos() {
+// final double ball_pos_x = (7.0 - 5.444) *inch;
+// final double ball_pos_y = 0.574*inch;
+// final double ball_pos_z = SupportRing.plateThickness + kin_mount_offset_vertically;
+// ballPos = new BasicHep3Vector(ball_pos_x, ball_pos_y, ball_pos_z);
+//
+// final double vee_pos_x = (2*7.0)*inch;
+// final double vee_pos_y = ball_pos_y;
+// final double vee_pos_z = ball_pos_z;
+// veePos = new BasicHep3Vector(vee_pos_x, vee_pos_y, vee_pos_z);
+//
+// final double flat_pos_x = ball_pos_x;
+// final double flat_pos_y = ball_pos_y + 1.0; // random distance
+// final double flat_pos_z = ball_pos_z;
+// flatPos = new BasicHep3Vector(flat_pos_x,flat_pos_y,flat_pos_z);
+// }
+
+ }
+
+ /**
+ * @SurveyVolume volume defining a coordinate system from the kinematic mount positions for support channels
+ * Reference: @SupportRing coordinate system
+ * Origin: cone mount (it's on the electron side)
+ * Orientation: ball is cone mount, slot mount is vee position and flat is along beamline pointing upstream
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class SupportRingL13TopKinMount extends SupportRingL13KinMount {
+ //public static final double mount_surface_wrt_baseplate_vertically = 5.388*inch;
+ protected static final double kin_mount_pos_z = 56.857;
+
+ public SupportRingL13TopKinMount(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection) {
+ super(name, mother, alignmentCorrection);
+ init();
+ }
+
+ @Override
+ protected double getKinMountVerticalPos() {
+ return kin_mount_pos_z;
+ }
+
+// protected void setPos() {
+// final double ball_pos_x = (7.0 - 5.444) *inch;
+// final double ball_pos_y = 0.574*inch;
+// final double ball_pos_z = mount_surface_wrt_baseplate_vertically + kin_mount_offset_vertically;
+// ballPos = new BasicHep3Vector(ball_pos_x, ball_pos_y, ball_pos_z);
+//
+// final double vee_pos_x = (2*7.0)*inch;
+// final double vee_pos_y = ball_pos_y;
+// final double vee_pos_z = ball_pos_z;
+// veePos = new BasicHep3Vector(vee_pos_x, vee_pos_y, vee_pos_z);
+//
+// final double flat_pos_x = ball_pos_x;
+// final double flat_pos_y = ball_pos_y + 1.0; // random distance
+// final double flat_pos_z = ball_pos_z;
+// flatPos = new BasicHep3Vector(flat_pos_x,flat_pos_y,flat_pos_z);
+// }
+ }
+
+
+ /**
+ * Abstract @SurveyVolume volume defining the coordinate system of the L1-3 u-channels
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+ public abstract static class UChannelL13 extends SurveyVolume {
+ public final static double length = UChannelL13Plate.length;
+ public static final double width = UChannelL13Plate.width;
+ public static final double height = 2.575*inch;
+ public static final double kin_mount_to_edge_of_plate_x = width/2.0-4.0*inch;
+ public static final double side_plate_cone_y = 2.0*inch;
+
+ public UChannelL13(String name, SurveyVolume m, AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ }
+
+ protected void setBoxDim() {
+ setBoxDim(getWidth(),getLength(),getHeight());
+ }
+ protected double getLength() {
+ return length;
+ }
+ protected double getWidth() {
+ return width;
+ }
+ protected double getHeight() {
+ return height;
+ }
+ }
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the bottom L1-3 u-channel
+ * Reference: SupportRingL13BottomKinMount coordinate system
+ * Origin: midpoint between upstream survey cones
+ * Orientation: u - width pointing towards electron side, v - pointing along the U-channel in the beam direction
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL13Bottom extends UChannelL13 {
+ private final static double cone_to_edge_of_plate_y = 12.25*inch;
+ private final static Hep3Vector ball_kinMount = new BasicHep3Vector(SupportRingL13BottomKinMount.kin_mount_pos_x,SupportRingL13BottomKinMount.kin_mount_pos_y,SupportRingL13BottomKinMount.kin_mount_pos_z);
+
+ public UChannelL13Bottom(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ init();
+ }
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = cone_to_edge_of_plate_y - length/2.0;
+ final double z = -side_plate_cone_y - UChannelL13Plate.height + height/2.0;
+ setCenter(x,y,z);
+ }
+ protected void setPos() {
+ ballPos = VecOp.sub(UChannelL13BottomSurveyBalls.ball_pos, ball_kinMount);
+ Hep3Vector veeOffset = UChannelL13BottomSurveyBalls.getVeeOffset();
+ veePos = VecOp.add(ballPos, veeOffset);
+ Hep3Vector flatOffset = UChannelL13BottomSurveyBalls.getFlatOffset();
+ flatPos = VecOp.add(ballPos, flatOffset);
+
+// ballPos = VecOp.sub(UChannelL13BottomSurveyBalls.ball_pos, ball_kinMount);
+// veePos = new BasicHep3Vector(ballPos.x()-1, ballPos.y(), ballPos.z());
+// flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()-1, ballPos.z());
+ }
+ }
+
+
+
+ /**
+ * Position of the center of the survey balls when engaging the cones in the side plates of the U-channel.
+ * This is at nominal position.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ private static class UChannelL13BottomSurveyBalls {
+
+ // Shawn's calculated point at midpoint between two forward survey balls
+ protected final static Hep3Vector ball_pos = new BasicHep3Vector(-46.446, 241.184, -8.423);
+
+ //Nominal Design FWD Right (x,y,z) BWD Right (x,y,z) FWD Left (x,y,z,) BWD Left (x,y,z)
+ //
+ //Layer 1-3, Lower -6.493, -.332, 9.353 -6.253, -.332, 1.483 2.836, -.332, 9.638 3.076, -.332, 1.767
+ //
+ //Layer 1-3, Upper -6.512, .332, 9.978 -6.272, .332, 2.107 2.817, .332, 10.262 3.057, .332, 2.392
+
+
+ protected static final Hep3Vector fwd_right = new BasicHep3Vector(-6.493, 9.353,-.332);
+ protected static final Hep3Vector bwd_right = new BasicHep3Vector(-6.253, 1.483, -.332);
+ protected static final Hep3Vector fwd_left = new BasicHep3Vector( 2.836, 9.638, -.332);
+ protected static final Hep3Vector bwd_left = new BasicHep3Vector(3.076, 1.767, -.332);
+
+ protected static Hep3Vector getVeeOffset() {
+ return VecOp.mult(0.5,VecOp.sub(fwd_right, fwd_left));
+ }
+ protected static Hep3Vector getFlatOffset() {
+ return VecOp.sub(bwd_right, fwd_right);
+ }
+ }
+
+
+
+
+
+
+// public static class UChannelL13Bottom extends UChannelL13 {
+// private static final double kin_mount_to_edge_of_plate_y = length-15.8*inch;
+// private final static double cone_to_edge_of_plate_y = 12.25*inch;
+// //private final static double cone_to_L1_hole_y = cone_to_edge_of_plate_y - kin_mount_to_edge_of_plate_y;
+// public UChannelL13Bottom(String name, SurveyVolume m,
+// AlignmentCorrection alignmentCorrection,
+// SurveyVolume ref) {
+// super(name, m, alignmentCorrection, ref);
+// init();
+// }
+// protected void setCenter() {
+// final double x = 0.0;
+// final double y = cone_to_edge_of_plate_y - length/2.0;
+// final double z = -side_plate_cone_y - UChannelL13Plate.height + height/2.0;
+// setCenter(x,y,z);
+// }
+// protected void setPos() {
+// final double ball_pos_x = 4*inch;
+// //final double ball_pos_y = (4.175 + 2*3.937) * inch;
+// final double ball_pos_y = cone_to_edge_of_plate_y - kin_mount_to_edge_of_plate_y;
+// final double ball_pos_z = -UChannelPlate.dist_from_plate_surface_to_pivot_point + UChannelL13Plate.height + side_plate_cone_y;
+//
+// ballPos = new BasicHep3Vector(ball_pos_x, ball_pos_y, ball_pos_z);
+// veePos = new BasicHep3Vector(ballPos.x()-1, ballPos.y(), ballPos.z());
+// flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()-1, ballPos.z());
+// }
+// }
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the top L1-3 u-channel
+ * Reference: SupportRingL13TopKinMount coordinate system
+ * Origin: midpoint between upstream survey cones
+ * Orientation: u - width pointing towards positron side, v - pointing along the U-channel in the beam direction
+ * Note that this is flipped w.r.t. bottom support.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL13Top extends UChannelL13 {
+ private final static Hep3Vector ball_kinMount = new BasicHep3Vector(SupportRingL13TopKinMount.kin_mount_pos_x,SupportRingL13TopKinMount.kin_mount_pos_y,SupportRingL13TopKinMount.kin_mount_pos_z);
+
+ private final static double length = UChannelL13.length;
+ //private static final double kin_mount_to_edge_of_plate_y = length-15.8*inch;
+ private final static double cone_to_side_plate_pin_y = (14.5-3.125)*inch;
+ private final static double side_plate_pin_to_edge_of_plate_y = (16.0-14.5)*inch;
+ private final static double cone_to_edge_of_plate_y = cone_to_side_plate_pin_y + side_plate_pin_to_edge_of_plate_y;
+
+ public UChannelL13Top(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ init();
+ }
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = cone_to_edge_of_plate_y - length/2.0;
+ final double z = -side_plate_cone_y - UChannelL13Plate.height + height/2.0;
+ setCenter(x,y,z);
+ }
+ protected void setPos() {
+ ballPos = VecOp.sub(UChannelL13TopSurveyBalls.ball_pos, ball_kinMount);
+ Hep3Vector veeOffset = UChannelL13TopSurveyBalls.getVeeOffset();
+ veePos = VecOp.add(ballPos, veeOffset);
+ Hep3Vector flatOffset = UChannelL13TopSurveyBalls.getFlatOffset();
+ flatPos = VecOp.add(ballPos, flatOffset);
+
+// ballPos = VecOp.sub(UChannelL13TopSurveyBalls.ball_pos, ball_kinMount);
+// veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+// flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()-1, ballPos.z());
+ }
+ protected double getLength() {
+ return length;
+ }
+ }
+
+
+
+ /**
+ * Position of the center of the survey balls when engaging the cones in the side plates of the U-channel.
+ * This is at nominal position.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ private static class UChannelL13TopSurveyBalls {
+
+ // Shawn's calculated point at midpoint between two forward survey balls
+ protected final static Hep3Vector ball_pos = new BasicHep3Vector(-46.930, 257.052, 8.423);
+
+ //Nominal Design FWD Right (x,y,z) BWD Right (x,y,z) FWD Left (x,y,z,) BWD Left (x,y,z)
+ //
+ //Layer 1-3, Lower -6.493, -.332, 9.353 -6.253, -.332, 1.483 2.836, -.332, 9.638 3.076, -.332, 1.767
+ //
+ //Layer 1-3, Upper -6.512, .332, 9.978 -6.272, .332, 2.107 2.817, .332, 10.262 3.057, .332, 2.392
+
+
+ protected static final Hep3Vector fwd_right = new BasicHep3Vector(-6.512, 9.978, .332);
+ protected static final Hep3Vector bwd_right = new BasicHep3Vector(-6.272, 2.107, .332);
+ protected static final Hep3Vector fwd_left = new BasicHep3Vector( 2.817, 10.262, .332);
+ protected static final Hep3Vector bwd_left = new BasicHep3Vector(3.057, 2.392, .332);
+
+ protected static Hep3Vector getVeeOffset() {
+ return VecOp.mult(0.5,VecOp.sub(fwd_left, fwd_right));
+ }
+ protected static Hep3Vector getFlatOffset() {
+ return VecOp.sub(bwd_left, fwd_left);
+ }
+ }
+
+
+
+
+
+// public static class UChannelL13Top extends UChannelL13 {
+// private final static double length = UChannelL13.length;
+// private static final double kin_mount_to_edge_of_plate_y = length-15.8*inch;
+// private final static double cone_to_side_plate_pin_y = (14.5-3.125)*inch;
+// private final static double side_plate_pin_to_edge_of_plate_y = (16.0-14.5)*inch;
+// private final static double cone_to_edge_of_plate_y = cone_to_side_plate_pin_y + side_plate_pin_to_edge_of_plate_y;
+//
+// public UChannelL13Top(String name, SurveyVolume m,
+// AlignmentCorrection alignmentCorrection,
+// SurveyVolume ref) {
+// super(name, m, alignmentCorrection, ref);
+// init();
+// }
+// protected void setCenter() {
+// final double x = 0.0;
+// final double y = cone_to_edge_of_plate_y - length/2.0;
+// final double z = -side_plate_cone_y - UChannelL13Plate.height + height/2.0;
+// setCenter(x,y,z);
+// }
+// protected void setPos() {
+// final double ball_pos_x = 4*inch;
+// final double ball_pos_y = cone_to_edge_of_plate_y - kin_mount_to_edge_of_plate_y;
+// final double ball_pos_z = SupportRingL13KinMount.kin_mount_offset_vertically - side_plate_cone_y;
+// // Note that this coordinate system is flipped pi compared to bottom
+// ballPos = new BasicHep3Vector(ball_pos_x, ball_pos_y, ball_pos_z);
+// veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+// flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()-1, ballPos.z());
+// }
+// protected double getLength() {
+// return length;
+// }
+// }
+
+
+
+ /**
+ * Abstract @SurveyVolume volume defining the coordinate system of the u-channel plate
+
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class UChannelPlate extends SurveyVolume {
+ public UChannelPlate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ }
+
+ // the kin mount cone is recessed into the plate meaning that the effective pivot axis is
+ // also recessed into the plate from the surface
+ public static final double dist_from_plate_surface_to_pivot_point = 0.0295*inch;
+ }
+
+ /**
+ * Abstract @SurveyVolume volume defining the coordinate system of the u-channel plate
+
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class UChannelL13Plate extends UChannelPlate {
+ private final static double pocket_depth_L1 = 0.025;
+ private final static double pocket_depth_L2 = pocket_depth_L1 + 0.059;
+ private final static double pocket_depth_L3 = pocket_depth_L2 + 0.059;
+ private final static double module_mounting_hole_to_hole_x =3.937*inch;
+ private static final double width = 9.25*inch;
+ protected static final double height = 0.375*inch;
+ protected final static double length = 16.0*inch;
+
+
+
+ public UChannelL13Plate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ setMaterial("Aluminum");
+ }
+
+ /**
+ * Get pocket depth for this plate
+ * @param layer
+ * @return pocket depth
+ */
+ public static double getPocketDepth(int layer) {
+ if(layer==1) return pocket_depth_L1;
+ else if(layer==2) return pocket_depth_L2;
+ else if(layer==3) return pocket_depth_L3;
+ else {
+ throw new RuntimeException("Trying to create a L1-3 module with invalid layer nr: " + layer);
+ }
+ }
+
+ protected void setBoxDim() {
+ setBoxDim(getWidth(), getLength(), getHeight());
+ }
+
+ protected void setPos() {
+ ballPos = new BasicHep3Vector(0, 0, 0);
+ veePos = new BasicHep3Vector(1, 0, 0);
+ flatPos = new BasicHep3Vector(0, 1, 0);
+ }
+
+ public double getWidth() {
+ return width;
+ }
+ public double getLength() {
+ return length;
+ }
+ public double getHeight() {
+ return height;
+ }
+
+ }
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the bottom u-channel plate
+ * Reference: @UChannelL13Bottom coordinate system
+ * Origin: same as reference
+ * Orientation: same as reference
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL13BottomPlate extends UChannelL13Plate {
+ protected final static double L1_module_pin_to_edge_of_plate = (16.0-4.126)*inch;
+
+ public UChannelL13BottomPlate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ init();
+ }
+
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = UChannelL13Bottom.cone_to_edge_of_plate_y - length/2.0;
+ final double z = -UChannelL13.side_plate_cone_y - height/2.0;
+ setCenter(x,y,z);
+ }
+
+ }
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the bottom u-channel plate
+ * Reference: @UChannelL13Bottom coordinate system
+ * Origin: same as reference
+ * Orientation: same as reference
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL13TopPlate extends UChannelL13Plate {
+ protected final static double L1_module_pin_to_edge_of_plate = (16.0-2.75)*inch;
+
+ public UChannelL13TopPlate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ init();
+ }
+
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = UChannelL13Top.cone_to_edge_of_plate_y - length/2.0;
+ final double z = -UChannelL13.side_plate_cone_y - height/2.0;
+ setCenter(x,y,z);
+ }
+
+ }
+
+
+ /**
+ * Abstract @SurveyVolume volume defining the L4-6 u-channel volume
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+ public abstract static class UChannelL46 extends SurveyVolume {
+
+ protected static final double width = UChannelL46Plate.width;
+ protected static final double length = UChannelL46Plate.length;
+ protected static final double height = 2.575*inch;
+ private static final double kin_mount_to_edge_of_plate_x = width/2.0-5.75*inch;
+ private static final double kin_mount_to_edge_of_plate_y = 0.2*inch;
+ protected static final double side_plate_cone_y = 2.0*inch;
+
+ public UChannelL46(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection) {
+ super(name, m, alignmentCorrection);
+ }
+
+ protected void setBoxDim() {
+ setBoxDim(width,length,height);
+ }
+
+ }
+
+
+
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the u-channel
+ * Reference: SVTBox coordinate system
+ * Origin: midpoint between upstream survey cones
+ * Orientation: u - width pointing towards electron side, v - pointing along the U-channel in the beam direction
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL46Bottom extends UChannelL46 {
+
+
+ protected static final double cone_to_edge_of_plate_y = 2.75*inch;
+
+ public UChannelL46Bottom(String name, SurveyVolume m, AlignmentCorrection alignmentCorrection) {
+ super(name, m, alignmentCorrection);
+ init();
+ }
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = -cone_to_edge_of_plate_y + length/2.0;
+ final double z = -side_plate_cone_y - UChannelL46Plate.height + height/2.0;
+ setCenter(x,y,z);
+ }
+ protected void setPos() {
+ ballPos = UChannelL46BottomSurveyBalls.ball_pos;
+ Hep3Vector veeOffset = UChannelL46BottomSurveyBalls.getVeeOffset();
+ veePos = VecOp.add(ballPos, veeOffset);
+ Hep3Vector flatOffset = UChannelL46BottomSurveyBalls.getFlatOffset();
+ flatPos = VecOp.add(ballPos, flatOffset);
+ }
+ }
+
+ /**
+ * Position of the center of the survey balls when engaging the cones in the side plates of the U-channel.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ private static class UChannelL46BottomSurveyBalls {
+
+ // Shawn's calculated point at midpoint between two forward survey balls
+ protected final static Hep3Vector ball_pos = new BasicHep3Vector(-5.857, -157.776, -8.423);
+
+
+ private static final double cone_fwd_right_x = -7.019*inch;
+ private static final double cone_fwd_right_y = -6.419*inch;
+ private static final double cone_fwd_right_z = -0.332*inch;
+
+ private static final double cone_bwd_right_x = -6.539*inch;
+ private static final double cone_bwd_right_y = -22.159*inch;
+ private static final double cone_bwd_right_z = -0.332*inch;
+
+ private static final double cone_fwd_left_x = 6.558*inch;
+ private static final double cone_fwd_left_y = -6.005*inch;
+ private static final double cone_fwd_left_z = -0.332*inch;
+
+ private static final double cone_bwd_left_x = 7.038*inch;
+ private static final double cone_bwd_left_y = -21.745*inch;
+ private static final double cone_bwd_left_z = -0.332*inch;
+
+ protected static final Hep3Vector fwd_right = new BasicHep3Vector(cone_fwd_right_x, cone_fwd_right_y, cone_fwd_right_z);
+ protected static final Hep3Vector fwd_left = new BasicHep3Vector(cone_fwd_left_x, cone_fwd_left_y, cone_fwd_left_z);
+ protected static final Hep3Vector bwd_right = new BasicHep3Vector(cone_bwd_right_x, cone_bwd_right_y, cone_bwd_right_z);
+ protected static final Hep3Vector bwd_left = new BasicHep3Vector(cone_bwd_left_x, cone_bwd_left_y, cone_bwd_left_z);
+
+ protected static Hep3Vector getVeeOffset() {
+ return VecOp.mult(0.5,VecOp.sub(fwd_right, fwd_left));
+ }
+ protected static Hep3Vector getFlatOffset() {
+ return VecOp.sub(bwd_left, fwd_left);
+ }
+ }
+
+
+
+
+// public static class UChannelL46Bottom extends UChannelL46 {
+// // Coordinates of the survey ball engaging the machined features
+// protected static final double cone_fwd_right_x = -7.019*inch;
+// protected static final double cone_fwd_right_y = -6.419*inch;
+// protected static final double cone_fwd_right_z = -0.332*inch;
+//
+// protected static final double cone_bwd_right_x = -6.539*inch;
+// protected static final double cone_bwd_right_y = -22.159*inch;
+// protected static final double cone_bwd_right_z = -0.332*inch;
+//
+// protected static final double cone_fwd_left_x = 6.558*inch;
+// protected static final double cone_fwd_left_y = -6.005*inch;
+// protected static final double cone_fwd_left_z = -0.332*inch;
+//
+// protected static final double cone_bwd_left_x = 7.038*inch;
+// protected static final double cone_bwd_left_y = -21.745*inch;
+// protected static final double cone_bwd_left_z = -0.332*inch;
+//
+// protected static final double cone_to_edge_of_plate_y = 2.75*inch;
+//
+// public UChannelL46Bottom(String name, SurveyVolume m,
+// AlignmentCorrection alignmentCorrection) {
+// super(name, m, alignmentCorrection);
+// init();
+// }
+// protected void setCenter() {
+// final double x = 0.0;
+// final double y = -cone_to_edge_of_plate_y + length/2.0;
+// final double z = -side_plate_cone_y - UChannelL46Plate.height + height/2.0;
+// setCenter(x,y,z);
+// }
+// protected void setPos() {
+// //locate coordinate system from cone in mother coordinate system
+// Hep3Vector fwd_right = new BasicHep3Vector(cone_fwd_right_x, cone_fwd_right_y, cone_fwd_right_z);
+// Hep3Vector fwd_left = new BasicHep3Vector(cone_fwd_left_x, cone_fwd_left_y, cone_fwd_left_z);
+// Hep3Vector bwd_right = new BasicHep3Vector(cone_bwd_right_x, cone_bwd_right_y, cone_bwd_right_z);
+// Hep3Vector bwd_left = new BasicHep3Vector(cone_bwd_left_x, cone_bwd_left_y, cone_bwd_left_z);
+//
+// Hep3Vector d = VecOp.mult(0.5,VecOp.sub(fwd_left, fwd_right));
+// ballPos = VecOp.add(fwd_right, d);
+// veePos = fwd_right;
+// d = VecOp.mult(0.5, VecOp.sub(bwd_left, bwd_right));
+// flatPos = VecOp.add(bwd_right, d);
+// }
+// }
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the u-channel
+ * Reference: SVTBox coordinate system
+ * Origin: midpoint between upstream survey cones
+ * Orientation: u - width pointing towards electron side, v - pointing along the U-channel in the beam direction
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL46Top extends UChannelL46 {
+
+
+ private static final double cone_to_side_plate_pin_y = (0.875-0.25)*inch;
+ private static final double side_plate_pin_to_edge_of_plate_y = 1.5*inch;
+
+ protected static final double cone_to_edge_of_plate_y = cone_to_side_plate_pin_y + side_plate_pin_to_edge_of_plate_y;
+
+ public UChannelL46Top(String name, SurveyVolume m, AlignmentCorrection alignmentCorrection) {
+ super(name, m, alignmentCorrection);
+ init();
+ }
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = -cone_to_edge_of_plate_y + length/2.0;
+ final double z = -side_plate_cone_y - UChannelL46Plate.height + height/2.0;
+ setCenter(x,y,z);
+ }
+ protected void setPos() {
+
+ ballPos = UChannelL46TopSurveyBalls.ball_pos;
+ Hep3Vector veeOffset = UChannelL46TopSurveyBalls.getVeeOffset();
+ veePos = VecOp.add(ballPos, veeOffset);
+ Hep3Vector flatOffset = UChannelL46TopSurveyBalls.getFlatOffset();
+ flatPos = VecOp.add(ballPos, flatOffset);
+
+ //ballPos = ball_pos;
+ //veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z()); // note sign change on random offset w.r.t. bottom
+ //flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()-1, ballPos.z()); // random offset
+ }
+ }
+
+
+ /**
+ * Position of the center of the survey balls when engaging the cones in the side plates of the U-channel.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ private static class UChannelL46TopSurveyBalls {
+
+ // Shawn's calculated point at midpoint between two forward survey balls
+ protected final static Hep3Vector ball_pos = new BasicHep3Vector(-6.341, -141.909, 8.423);
+
+
+ protected static final double cone_fwd_right_x = -7.038*inch;
+ protected static final double cone_fwd_right_y = -5.794*inch;
+ protected static final double cone_fwd_right_z = 0.332*inch;
+
+ protected static final double cone_bwd_right_x = -6.558*inch;
+ protected static final double cone_bwd_right_y = -21.535*inch;
+ protected static final double cone_bwd_right_z = 0.332*inch;
+
+ protected static final double cone_fwd_left_x = 6.539*inch;
+ protected static final double cone_fwd_left_y = -5.380*inch;
+ protected static final double cone_fwd_left_z = 0.332*inch;
+
+ protected static final double cone_bwd_left_x = 7.019*inch;
+ protected static final double cone_bwd_left_y = -21.121*inch;
+ protected static final double cone_bwd_left_z = 0.332*inch;
+
+ protected static final Hep3Vector fwd_right = new BasicHep3Vector(cone_fwd_right_x, cone_fwd_right_y, cone_fwd_right_z);
+ protected static final Hep3Vector fwd_left = new BasicHep3Vector(cone_fwd_left_x, cone_fwd_left_y, cone_fwd_left_z);
+ protected static final Hep3Vector bwd_right = new BasicHep3Vector(cone_bwd_right_x, cone_bwd_right_y, cone_bwd_right_z);
+ protected static final Hep3Vector bwd_left = new BasicHep3Vector(cone_bwd_left_x, cone_bwd_left_y, cone_bwd_left_z);
+
+ protected static Hep3Vector getVeeOffset() {
+ return VecOp.mult(0.5,VecOp.sub(fwd_left, fwd_right));
+ }
+ protected static Hep3Vector getFlatOffset() {
+ return VecOp.sub(bwd_right, fwd_right);
+ }
+ }
+
+
+// public static class UChannelL46Top extends UChannelL46 {
+// // Coordinates of the survey ball engaging the machined features
+// protected static final double cone_fwd_right_x = -7.038*inch;
+// protected static final double cone_fwd_right_y = -5.794*inch;
+// protected static final double cone_fwd_right_z = 0.332*inch;
+//
+// protected static final double cone_bwd_right_x = -6.558*inch;
+// protected static final double cone_bwd_right_y = -21.535*inch;
+// protected static final double cone_bwd_right_z = 0.332*inch;
+//
+// protected static final double cone_fwd_left_x = 6.539*inch;
+// protected static final double cone_fwd_left_y = -5.380*inch;
+// protected static final double cone_fwd_left_z = 0.332*inch;
+//
+// protected static final double cone_bwd_left_x = 7.019*inch;
+// protected static final double cone_bwd_left_y = -21.121*inch;
+// protected static final double cone_bwd_left_z = 0.332*inch;
+//
+// private static final double cone_to_side_plate_pin_y = (0.875-0.25)*inch;
+// private static final double side_plate_pin_to_edge_of_plate_y = 1.5*inch;
+//
+// protected static final double cone_to_edge_of_plate_y = cone_to_side_plate_pin_y + side_plate_pin_to_edge_of_plate_y;
+//
+// public UChannelL46Top(String name, SurveyVolume m,
+// AlignmentCorrection alignmentCorrection) {
+// super(name, m, alignmentCorrection);
+// init();
+// }
+// protected void setCenter() {
+// final double x = 0.0;
+// final double y = -cone_to_edge_of_plate_y + length/2.0;
+// final double z = -side_plate_cone_y - UChannelL46Plate.height + height/2.0;
+// setCenter(x,y,z);
+// }
+// protected void setPos() {
+//
+// //locate coordinate system from cone in mother coordinate system
+// Hep3Vector fwd_right = new BasicHep3Vector(cone_fwd_right_x, cone_fwd_right_y, cone_fwd_right_z);
+// Hep3Vector fwd_left = new BasicHep3Vector(cone_fwd_left_x, cone_fwd_left_y, cone_fwd_left_z);
+// Hep3Vector bwd_right = new BasicHep3Vector(cone_bwd_right_x, cone_bwd_right_y, cone_bwd_right_z);
+// Hep3Vector bwd_left = new BasicHep3Vector(cone_bwd_left_x, cone_bwd_left_y, cone_bwd_left_z);
+//
+// Hep3Vector d = VecOp.mult(0.5,VecOp.sub(fwd_left, fwd_right));
+// ballPos = VecOp.add(fwd_right, d);
+// veePos = fwd_left;
+// d = VecOp.mult(0.5, VecOp.sub(bwd_left, bwd_right));
+// flatPos = VecOp.add(bwd_right, d);
+//
+// }
+// }
+
+
+
+ /**
+ * Abstract @SurveyVolume defining the coordinate system of the u-channel plates
+
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class UChannelL46Plate extends UChannelPlate {
+ public final static double pocket_depth_L4 = 0.1;
+ public final static double pocket_depth_L5 = pocket_depth_L4 + 0.118;
+ public final static double pocket_depth_L6 = pocket_depth_L5 + 0.118;
+ public final static double module_mounting_hole_to_hole_x =7.874*inch;
+ public static final double width = 13.5*inch;
+ public static final double length = 21.0*inch;
+ public static final double height = 0.5*inch;
+
+ public UChannelL46Plate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ setMaterial("Aluminum");
+ }
+
+ /**
+ * Get pocket depth for this plate
+ * @param layer
+ * @return pocket depth
+ */
+ public static double getPocketDepth(int layer) {
+ if(layer==4) return pocket_depth_L4;
+ else if(layer==5) return pocket_depth_L5;
+ else if(layer==6) return pocket_depth_L6;
+ else {
+ throw new RuntimeException("Trying to create a L4-6 module with invalid layer nr: " + layer);
+ }
+ }
+
+ protected void setBoxDim() {
+ setBoxDim(getWidth(),getLength(),getHeight());
+ }
+
+ protected void setPos() {
+ ballPos = new BasicHep3Vector(0, 0, 0);
+ veePos = new BasicHep3Vector(1, 0, 0);
+ flatPos = new BasicHep3Vector(0, 1, 0);
+ }
+
+ public double getWidth() {
+ return width;
+ }
+
+ public double getLength() {
+ return length;
+ }
+
+ public double getHeight() {
+ return height;
+ }
+ }
+
+ /**
+ * @SurveyVolume defining the coordinate system of the bottom u-channel plate
+ * Reference: @UChannelL13Bottom coordinate system
+ * Origin: same as reference
+ * Orientation: same as reference
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL46BottomPlate extends UChannelL46Plate {
+ protected final static double L4_module_pin_to_edge_of_plate = 3.125*inch;
+
+ public UChannelL46BottomPlate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ init();
+ }
+
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = -UChannelL46Bottom.cone_to_edge_of_plate_y + length/2.0;
+ final double z = -UChannelL46.side_plate_cone_y - height/2.0;
+ setCenter(x,y,z);
+ }
+
+ }
+
+
+ /**
+ * @SurveyVolume defining the coordinate system of the top u-channel plate
+ * Reference: @UChannelL13Top coordinate system
+ * Origin: same as reference
+ * Orientation: same as reference
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class UChannelL46TopPlate extends UChannelL46Plate {
+ protected final static double L4_module_pin_to_edge_of_plate = 1.75*inch;
+
+ public UChannelL46TopPlate(String name, SurveyVolume m,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, m, alignmentCorrection, ref);
+ init();
+ }
+
+ protected void setCenter() {
+ final double x = 0.0;
+ final double y = -UChannelL46Top.cone_to_edge_of_plate_y + length/2.0;
+ final double z = -UChannelL46.side_plate_cone_y - height/2.0;
+ setCenter(x,y,z);
+ }
+
+ }
+
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of module L1-3
+ * Reference: @UChannelL13Bottom coordinate system
+ * Origin: hole position on mounting surface (on electron side)
+ * Orientation: u - is normal to the surface pointing vertically down, v - points along module away from hybrid side (i.e. positron direction).
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class ModuleL13 extends BaseModule {
+ private final static double box_extra_length = 10.0;// random at this point
+ private final static double box_extra_height = -0.45*inch;// random at this point
+ private final static double box_extra_width = 0.5*inch;// random at this point
+
+ private static final double tension_lever_y = 2.5*inch;
+ // TODO the dimension of this volume is padded manually. Check if this can cause overlap problems
+ public static final double length = 8.0*inch + box_extra_length;
+ public static final double height = 1.0*inch + box_extra_height;
+ private static final double width = tension_lever_y + 0.04*inch + box_extra_width;
+ //private static final double hole_to_end_of_module_x = 7.750*inch;
+ //private static final double hole_to_module_edge_height_dir = height - 0.875*inch;
+ protected static final double hole_to_center_of_plate_width_dir = 3.75*inch;
+ private static final double hole_to_module_edge_length_dir = 0.25*inch;
+
+ public ModuleL13(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref, getLayerFromVolumeName(name), getHalfFromName(name));
+
+ }
+ protected void setCenter() {
+ final double x = -width/2.0;
+ final double y = -hole_to_module_edge_length_dir + length/2.0;
+ //center this volume around the center of the module which is the same as the cone for L1
+ //final double z = hole_to_module_edge_height_dir - height/2.0;
+ final double z = -Math.abs(getHoleModuleCenterOffset());
+ setCenter(x,y,z);
+ }
+ protected void setBoxDim() {
+ setBoxDim(width, length, height);
+ }
+ protected abstract void setPos();
+ protected abstract double getHoleModuleCenterOffset();
+ protected abstract Hep3Vector getHolePosition();
+ }
+
+ public abstract static class ModuleL13Top extends ModuleL13 {
+ public ModuleL13Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ }
+ protected void setPos() {
+ ballPos = getHolePosition();
+ veePos = new BasicHep3Vector(ballPos.x(), ballPos.y(), ballPos.z()-1.0);
+ flatPos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ }
+ protected double getHoleModuleCenterOffset() {
+ return UChannelL13Top.cone_to_edge_of_plate_y - UChannelL13TopPlate.L1_module_pin_to_edge_of_plate;
+ }
+
+ }
+
+ public abstract static class ModuleL13Bot extends ModuleL13 {
+ public ModuleL13Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ }
+ protected void setPos() {
+ ballPos = getHolePosition();
+ veePos = new BasicHep3Vector(ballPos.x(), ballPos.y(), ballPos.z()-1.0);
+ flatPos = new BasicHep3Vector(ballPos.x()-1, ballPos.y(), ballPos.z());
+ }
+ protected double getHoleModuleCenterOffset() {
+ return UChannelL13Bottom.cone_to_edge_of_plate_y - UChannelL13BottomPlate.L1_module_pin_to_edge_of_plate;
+ }
+ }
+
+
+ public static class ModuleL1Bot extends ModuleL13Bot {
+
+ public ModuleL1Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+ protected Hep3Vector getHolePosition() {
+ double x = 95.25;
+ double y = 9.525;
+ double z = -51.435;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+
+ public static class ModuleL1Top extends ModuleL13Top {
+
+ public ModuleL1Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHolePosition() {
+ double x = -95.25; // note minus sign compared to bottom
+ double y = -9.525;
+ double z = -51.435;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+
+
+ public static class ModuleL2Bot extends ModuleL13Bot {
+
+ public ModuleL2Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+ protected Hep3Vector getHolePosition() {
+ double x = 95.25;
+ double y = 109.525;
+ double z = -51.435 - 1.5;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+ public static class ModuleL2Top extends ModuleL13Top {
+
+ public ModuleL2Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHolePosition() {
+ double x = -95.25; // note minus sign compared to bottom
+ double y = 90.475;
+ double z = -51.435 - 1.5;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+
+
+
+ public static class ModuleL3Bot extends ModuleL13Bot {
+
+ public ModuleL3Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+ protected Hep3Vector getHolePosition() {
+ double x = 95.25;
+ double y = 209.525;
+ double z = -51.435 - 2*1.5;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+ public static class ModuleL3Top extends ModuleL13Top {
+
+ public ModuleL3Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHolePosition() {
+ double x = -95.25; // note minus sign compared to bottom
+ double y = 190.475;
+ double z = -51.435 - 2*1.5;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+
+
+
+
+ /**
+ * Abstract @SurveyVolume volume defining the coordinate system of module L4-6
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class ModuleL46 extends BaseModule {
+ protected final static double hole_to_center_of_plate_width_dir = 5.875*inch;
+ protected final static double hole_to_module_edge_height_dir = 0.875*inch;
+ protected static final double hole_to_module_edge_length_dir = 0.25*inch;
+ private final static double box_extra_length = 0.0;// random at this point
+ private final static double box_extra_height = -0.45*inch;// random at this point
+ private final static double box_extra_width = 0.5*inch;// random at this point
+
+ private static final double tension_lever_y = 2.5*inch;
+ // TODO the dimension of the L4-6 module is completely made up
+ public static final double length = 12.25*inch + box_extra_length;
+ public static final double height = 1.0*inch + box_extra_height;
+ public static final double width = tension_lever_y + 0.04*inch + box_extra_width;
+
+ public ModuleL46(String name, SurveyVolume mother, AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref, getLayerFromVolumeName(name), getHalfFromName(name));
+
+ }
+ protected void setCenter() {
+ final double x = -width/2.0;
+ final double y = -hole_to_module_edge_length_dir + length/2.0;
+ final double z = -Math.abs(getHoleModuleCenterOffset());
+ //final double z = -hole_to_module_edge_height_dir + height/2.0;
+ setCenter(x,y,z);
+ }
+ protected void setBoxDim() {
+ setBoxDim(width, length, height);
+ }
+ protected abstract void setPos();
+ protected abstract double getHoleModuleCenterOffset();
+ protected abstract Hep3Vector getHole();
+ }
+
+
+ /**
+ * Abstract @SurveyVolume volume defining the coordinate system of bottom modules for L4-6
+ * Reference: @UChannelL46Bottom coordinate system
+ * Origin: hole position on mounting surface (electron side)
+ * Orientation: u - is normal to the mounting surface pointing vertically down, v - points along module towards positron side.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static abstract class ModuleL46Bot extends ModuleL46 {
+
+ public ModuleL46Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ }
+ protected void setPos() {
+ ballPos = getHole();
+ veePos = new BasicHep3Vector(ballPos.x(), ballPos.y(), ballPos.z()-1.0);
+ flatPos = new BasicHep3Vector(ballPos.x()-1.0, ballPos.y(), ballPos.z());
+ }
+ protected double getHoleModuleCenterOffset() {
+ return UChannelL46Bottom.cone_to_edge_of_plate_y - UChannelL46BottomPlate.L4_module_pin_to_edge_of_plate;
+ }
+ }
+
+ /**
+ * Abstract @SurveyVolume volume defining the coordinate system of top modules for L4-6
+ * Reference: @UChannelL46Top coordinate system
+ * Origin: hole position on mounting surface (electron side when installed)
+ * Orientation: u - is normal to the mounting surface pointing vertically down, v - points along module towards electron side when installed.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static abstract class ModuleL46Top extends ModuleL46 {
+
+ public ModuleL46Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ }
+ protected void setPos() {
+ ballPos = getHole();
+ veePos = new BasicHep3Vector(ballPos.x(), ballPos.y(), ballPos.z()-1.0);
+ flatPos = new BasicHep3Vector(ballPos.x()+1.0, ballPos.y(), ballPos.z());
+ }
+ protected double getHoleModuleCenterOffset() {
+ return UChannelL46Top.cone_to_edge_of_plate_y - UChannelL46TopPlate.L4_module_pin_to_edge_of_plate;
+ }
+
+ }
+
+
+ public static class ModuleL4Bot extends ModuleL46Bot {
+
+ public ModuleL4Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHole() {
+ double x = 149.225;
+ double y = 9.525;
+ double z = -53.34;
+ //double x = hole_to_center_of_plate_width_dir;
+ //double y = -getHoleModuleCenterOffset(); //Note minus sign compared to top
+ //double z = -UChannelL46.side_plate_cone_y - UChannelL46Plate.pocket_depth_L4;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+ public static class ModuleL4Top extends ModuleL46Top {
+
+ public ModuleL4Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHole() {
+ double x = -149.225;
+ double y = -9.525;
+ double z = -53.34;
+// double x = -1*hole_to_center_of_plate_width_dir;
+// double y = -getHoleModuleCenterOffset();
+// double z = -UChannelL46.side_plate_cone_y - UChannelL46Plate.pocket_depth_L4;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+
+ public static class ModuleL5Bot extends ModuleL46Bot {
+
+ public ModuleL5Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHole() {
+ double x = 149.225;
+ double y = 209.525;
+ double z = -53.34 - 3.0;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+ public static class ModuleL5Top extends ModuleL46Top {
+
+ public ModuleL5Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHole() {
+ double x = -149.225;
+ double y = 190.475;
+ double z = -53.34 - 3.0;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+ public static class ModuleL6Bot extends ModuleL46Bot {
+
+ public ModuleL6Bot(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHole() {
+ double x = 149.225;
+ double y = 409.525;
+ double z = -53.34 - 2*3.0;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+ public static class ModuleL6Top extends ModuleL46Top {
+
+ public ModuleL6Top(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ super(name, mother, alignmentCorrection, ref);
+ init();
+ }
+
+ protected Hep3Vector getHole() {
+ double x = -149.225;
+ double y = 390.475;
+ double z = -53.34 - 2*3.0;
+ return new BasicHep3Vector(x, y, z);
+ }
+
+ }
+
+
+
+
+
+ public abstract static class LongHalfModule extends BaseModule {
+
+ //private static final double randomoffset = 5.0;
+ public static final double width = Sensor.width; // + randomoffset;
+ public static final double length = Sensor.length;// + randomoffset/10.0;
+ public static final double height = Sensor.height + HalfLongModuleLamination.height;
+ protected final static double sensor_z = 0.23*inch;
+
+
+ public LongHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ }
+
+ protected abstract Hep3Vector getSensorPosition();
+
+ protected void setBoxDim() {
+ setBoxDim(width, length, height);
+ }
+
+ protected void setCenter() {
+ double x = 0.0;
+ double y = 0.0;
+ double z = +0.5*Sensor.height - height/2.0;;
+ setCenter(x,y,z);
+ }
+
+ protected void setPos() {
+ ballPos = getSensorPosition(); //TODO make this get each coordinate instead.
+ veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()+1, ballPos.z());
+ }
+
+ }
+
+
+
+ public static class LongAxialHoleHalfModule extends LongHalfModule {
+
+ private final static double sensor_x = 1.382*inch;
+ private final static double sensor_y = 3.887*inch;
+
+
+ public LongAxialHoleHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+
+ protected Hep3Vector getSensorPosition() {
+ return new BasicHep3Vector(-sensor_x, sensor_y, -sensor_z);
+ }
+
+
+ }
+
+
+
+
+ public abstract static class LongAxialSlotHalfModuleBase extends LongHalfModule {
+
+ private final static double sensor_x = 1.382*inch;
+ private final static double sensor_y = 7.863*inch;
+
+ public LongAxialSlotHalfModuleBase(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ }
+
+ protected Hep3Vector getSensorPosition() {
+ return new BasicHep3Vector(-sensor_x, sensor_y, -sensor_z);
+ }
+
+ }
+
+ public static class LongAxialSlotHalfModule extends LongAxialSlotHalfModuleBase {
+
+ private final static double sensor_x = 1.382*inch;
+ private final static double sensor_y = 7.863*inch;
+
+
+ public LongAxialSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+
+ protected Hep3Vector getSensorPosition() {
+ return new BasicHep3Vector(-sensor_x, sensor_y, -sensor_z);
+ }
+ }
+
+
+ public abstract static class LongStereoHalfModule extends LongHalfModule {
+
+ protected final static double sensor_z = 0.52*inch;
+ protected final static double stereo_angle = 0.05;
+
+ public LongStereoHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ }
+
+
+ protected void applyGenericCoordinateSystemCorrections() {
+
+ // Rotate these into the right place for the stereo
+ // My rotations here are active rotations in the mother coordinate system frame
+
+ // flip around v ~ along the strips
+ Rotation r1 = new Rotation(new Vector3D(0,1,0),Math.PI);
+ // apply stereo angle around w ~ normal to the sensor plane
+ Rotation r2 = new Rotation(new Vector3D(0,0,1),stereo_angle);
+ // Build full rotation
+ Rotation r = r2.applyTo(r1);
+ //Rotation r = r1;
+ if(debug) {
+ System.out.printf("%s: LongStereoHalfModule Generic Corrections\n", getClass().getSimpleName());
+ System.out.printf("%s: Coord before corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ System.out.printf("%s: box center before corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ }
+
+ getCoord().rotateApache(r);
+
+ if(debug) {
+ System.out.printf("%s: Coord after corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ System.out.printf("%s: box center after corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ }
+
+ }
+
+
+
+
+ }
+
+
+ public static class LongStereoHoleHalfModule extends LongStereoHalfModule {
+
+ private final static double sensor_x = 1.282*inch;
+ private final static double sensor_y = 3.889*inch;
+
+ public LongStereoHoleHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+
+ protected Hep3Vector getSensorPosition() {
+ return new BasicHep3Vector(-sensor_x, sensor_y, -sensor_z);
+ }
+
+ }
+
+
+
+ public static abstract class LongStereoSlotHalfModuleBase extends LongStereoHalfModule {
+
+ private final static double sensor_x = 1.481*inch;
+ private final static double sensor_y = 7.861*inch;
+
+ public LongStereoSlotHalfModuleBase(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ }
+
+ protected Hep3Vector getSensorPosition() {
+ return new BasicHep3Vector(-sensor_x, sensor_y, -sensor_z);
+ }
+ }
+
+ public static class LongStereoSlotHalfModule extends LongStereoSlotHalfModuleBase {
+ public LongStereoSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+ }
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the axial half-module in module L1-3
+ * Reference: @ModuleL13Bot coordinate system
+ * Origin: sensor center
+ * Orientation: w - is normal to the surface pointing from p-side to n-side, v - points along strips away from signal bond pads
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class HalfModuleAxial extends HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule {
+ // Sensor positions from Shawn's 3D model
+ public static final double sensor_x = -1.543*inch;
+ public static final double sensor_y = 4.868*inch;
+ public static final double sensor_z = -0.23*inch;
+
+ public HalfModuleAxial(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+ protected void setPos() {
+ ballPos = getSensorPosition();
+ veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()+1, ballPos.z());
+ }
+ protected Hep3Vector getSensorPosition() {
+ return new BasicHep3Vector(sensor_x, sensor_y, sensor_z);
+ }
+ protected void setCenter() {
+ double x = -1.0 * (TestRunHalfModule.getWidth()/2.0 - ( 12.66 - (8.83 -3.00) + Sensor.width/2.0 ) );
+ double y = TestRunHalfModule.getLength()/2.0 - ( (170.00 + 10.00) - Sensor.length/2.0);
+ double z = -Sensor.getSensorThickness()/2.0 - HPSTestRunTracker2014GeometryDefinition.HalfModuleLamination.thickness - CarbonFiber.thickness + half_module_thickness/2.0;
+ setCenter(x, y, z);
+ }
+ }
+
+
+
+
+
+ /**
+ * @SurveyVolume volume defining the coordinate system of the stereo half-module in module L1-3
+ * Reference: @ModuleL13Bot coordinate system
+ * Origin: sensor center
+ * Orientation: same as axial - the module is rotated later.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class HalfModuleStereo extends HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule {
+
+ public static final double sensor_z = -0.52*inch;
+
+ public HalfModuleStereo(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ if(layer>=1 && layer<=3) stereo_angle = 0.1;
+ else throw new RuntimeException("Layer " + layer + " is ill-defined for test run modules");
+ init();
+ }
+ protected void setPos() {
+ // Sensor positions from Shawn's 3D model
+ final double x = HalfModuleAxial.sensor_x;
+ final double y = HalfModuleAxial.sensor_y;
+ final double z = sensor_z;
+ ballPos = new BasicHep3Vector(x, y, z);
+ veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()+1, ballPos.z());
+ }
+ protected void setCenter() {
+ double x = -1.0 * (TestRunHalfModule.getWidth()/2.0 - ( 12.66 - (8.83 -3.00) + Sensor.width/2.0 ) );
+ double y = TestRunHalfModule.getLength()/2.0 - ( (170.00 + 10.00) - Sensor.length/2.0);
+ double z = -Sensor.getSensorThickness()/2.0 - HPSTestRunTracker2014GeometryDefinition.HalfModuleLamination.thickness - CarbonFiber.thickness + half_module_thickness/2.0;
+ setCenter(x, y, z);
+ }
+ protected void applyGenericCoordinateSystemCorrections() {
+
+ // Rotate into the right place for the stereo - just offset compared to axial before this.
+ // My rotations here are active rotations in the mother coordinate system frame
+ // Sloppy description of the frame:
+ // x: direction along strips towards the readout bonds/apv25's
+ // v: normal to sensor plane pointing from the back-plane (n-side) to strip side (p-side)
+ // w: measurement direction with direction from right hand-rule
+
+ // flip around strip direction - sign doesn't matter
+ Rotation r1 = new Rotation(new Vector3D(0,1,0),Math.PI);
+ // apply stereo angle around v
+ Rotation r2 = new Rotation(new Vector3D(0,0,1),stereo_angle);
+ // Build full rotation
+ Rotation r = r2.applyTo(r1);
+ //Rotation r = r1;
+ if(debug) System.out.printf("%s: Coord before corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ if(debug) System.out.printf("%s: box center before corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ getCoord().rotateApache(r);
+ if(debug) System.out.printf("%s: Coord after corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ if(debug) System.out.printf("%s: box center after corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+
+ }
+
+
+ }
+
+
+ public static class HalfLongModuleLamination extends HPSTestRunTracker2014GeometryDefinition.HalfModuleComponent {
+ protected static final double width = Sensor.width;
+ protected static final double length = Sensor.length;
+ protected static final double height = 0.050;
+
+ public HalfLongModuleLamination(String name, SurveyVolume mother, int id) {
+ super(name, mother, null, id);
+ init();
+ }
+
+ protected double getThickness() {
+ return height;
+ }
+ protected double getHeigth() {
+ return height;
+ }
+ protected double getWidth() {
+ return width;
+ }
+ protected double getLength() {
+ return length;
+ }
+ protected void setPos() {
+ //offset enough to make them face-to-face
+ ballPos = new BasicHep3Vector(0, 0, -(Sensor.getSensorThickness()/2.0 + height/2.0));
+ veePos = new BasicHep3Vector(ballPos.x()+1, ballPos.y(), ballPos.z());
+ flatPos = new BasicHep3Vector(ballPos.x(), ballPos.y()+1, ballPos.z());
+ }
+ protected void setCenter() {
+ setCenter(0, 0, 0);
+ }
+ protected void setBoxDim() {
+ setBoxDim(width, length, height);
+ }
+ }
+
+
+
+ /**
+ * Create the module.
+ * @param layer - of the module
+ * @param half - top or bottom half of the tracker
+ */
+ protected void makeModuleBundle(int layer, String half)
+ {
+
+ if(isDebug()) System.out.printf("%s: makeModule for layer %d %s \n", this.getClass().getSimpleName(), layer, half);
+
+
+ // build the module name
+ String volName = "module_L"+ layer + (half=="bottom"?"b":"t");
+
+ // find the mother and reference geometry
+ // Note that the reference geometry is the support plate and since that is assumed to be
+ // created through it's references we don't need more than one reference to reach the mother coordinate system
+ final SurveyVolume mother = getSurveyVolume(SvtBox.class);
+ final SurveyVolume ref;
+ AlignmentCorrection alignmentCorrection = null;
+ if(half == "bottom") {
+ if(layer < 4) {
+ ref = getSurveyVolume(UChannelL13Bottom.class);
+ } else {
+ ref = getSurveyVolume(UChannelL46Bottom.class);
+ }
+ } else {
+ if(layer < 4) {
+ ref = getSurveyVolume(UChannelL13Top.class);
+ } else {
+ ref = getSurveyVolume(UChannelL46Top.class);
+ }
+ }
+
+ //Create the module
+ BaseModule module;
+ if(half == "bottom") {
+ if(layer==1) {
+ module = new ModuleL1Bot(volName, mother, alignmentCorrection, ref);
+ } else if(layer==2) {
+ module = new ModuleL2Bot(volName, mother, alignmentCorrection, ref);
+ } else if(layer==3) {
+ module = new ModuleL3Bot(volName, mother, alignmentCorrection, ref);
+ } else if(layer==4) {
+ module = new ModuleL4Bot(volName, mother, alignmentCorrection, ref);
+ } else if(layer==5) {
+ module = new ModuleL5Bot(volName, mother, alignmentCorrection, ref);
+ } else if(layer==6) {
+ module = new ModuleL6Bot(volName, mother, alignmentCorrection, ref);
+ } else {
+ throw new UnsupportedOperationException("Layer " + layer + " not implemented yet for bottom");
+ }
+ } else {
+ if(layer==1) {
+ module = new ModuleL1Top(volName, mother, alignmentCorrection, ref);
+ } else if(layer==2) {
+ module = new ModuleL2Top(volName, mother, alignmentCorrection, ref);
+ } else if(layer==3) {
+ module = new ModuleL3Top(volName, mother, alignmentCorrection, ref);
+ } else if(layer==4) {
+ module = new ModuleL4Top(volName, mother, alignmentCorrection, ref);
+ } else if(layer==5) {
+ module = new ModuleL5Top(volName, mother, alignmentCorrection, ref);
+ } else if(layer==6) {
+ module = new ModuleL6Top(volName, mother, alignmentCorrection, ref);
+ } else {
+ throw new UnsupportedOperationException("Layer " + layer + " not implemented yet for top");
+ }
+ }
+
+
+ // create the bundle for this module
+ // need to create it and add to list before half-module is created
+ // as it uses the list to find the bundle. Ugly. TODO fix this.
+ BaseModuleBundle bundle;
+
+ if(layer<=3) {
+ bundle = new TestRunModuleBundle(module);
+ addModuleBundle(bundle);
+ if(doAxial) makeHalfModule("axial", module);
+ // if(doColdBlock) makeColdBlock(module);
+ if(doStereo) makeHalfModule("stereo", module);
+ } else {
+ bundle = new LongModuleBundle(module);
+ addModuleBundle(bundle);
+ if(doAxial) {
+ makeLongHalfModule("axial","hole", module);
+ makeLongHalfModule("axial","slot", module);
+ }
+ // if(doColdBlock) makeColdBlock(module);
+ if(doStereo) {
+ makeLongHalfModule("stereo","hole", module);
+ makeLongHalfModule("stereo","slot", module);
+ }
+ }
+
+
+
+ if(isDebug()) {
+ System.out.printf("%s: created module bundle:\n", this.getClass().getSimpleName());
+ bundle.print();
+ System.out.printf("%s: Now there are %d modules\n", this.getClass().getSimpleName(),modules.size());
+ }
+
+
+
+ }
+
+
+
+
+
+ /**
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class LongModuleBundle extends BaseModuleBundle {
+ public HalfModuleBundle halfModuleAxialHole = null;
+ public HalfModuleBundle halfModuleStereoHole = null;
+ public HalfModuleBundle halfModuleAxialSlot = null;
+ public HalfModuleBundle halfModuleStereoSlot = null;
+ protected SurveyVolume coldBlock = null;
+ public LongModuleBundle(BaseModule m) {
+ super(m);
+ }
+ public void print() {
+ if(module!=null) System.out.printf("%s: %s\n", this.getClass().getSimpleName(),module.toString());
+ if(halfModuleAxialHole!=null) halfModuleAxialHole.print();
+ if(halfModuleAxialSlot!=null) halfModuleAxialSlot.print();
+ if(coldBlock!=null)System.out.printf("%s: %s\n", this.getClass().getSimpleName(),coldBlock.getName());
+ if(halfModuleStereoHole!=null) halfModuleStereoHole.print();
+ if(halfModuleStereoSlot!=null) halfModuleStereoSlot.print();
+ }
+ }
+
+
+ /**
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class LongHalfModuleBundle extends HalfModuleBundle {
+ public LongHalfModuleBundle() {
+ super();
+ }
+ public LongHalfModuleBundle(SurveyVolume hm) {
+ super(hm);
+ }
+ }
+
+
+
+ /**
+ * Create the half-module.
+ * @param side - stereo or axial
+ * @param type - hole or slot
+ * @param mother to the half-module
+ */
+ protected void makeLongHalfModule(String side, String type , BaseModule mother) {
+
+ String moduleName = mother.getName();
+
+ if(isDebug()) System.out.printf("%s: makeHalfModule for %s %s %s \n", this.getClass().getSimpleName(), moduleName, side, type);
+
+ String volName = moduleName + "_halfmodule_" + side + "_" + type;
+
+ // top or bottom?
+ String half = mother.getHalf();
+ boolean isTopLayer = !mother.isBottom();
+
+ // find layer
+ int layer = mother.getLayer();
+
+ // axial or stereo
+ boolean isAxial = isAxialFromName(volName);
+
+ // hole or slot
+ boolean isHole = isHoleFromName(volName);
+
+ // find layer according to Millepede layer definition
+ int millepedeLayer = getMillepedeLayer(isTopLayer, layer, isAxial, isHole);
+
+ // find alignment correction to this volume
+ AlignmentCorrection alignmentCorrection = getHalfModuleAlignmentCorrection(isTopLayer, millepedeLayer);
+
+
+ // find the module bundle that it will be added to
+ //TestRunModuleBundle bundle = (TestRunModuleBundle)getModuleBundle(mother);
+ //TestRunHalfModuleBundle halfModuleBundle;
+ LongModuleBundle bundle = (LongModuleBundle)getModuleBundle(mother);
+
+
+
+
+ // Build the half-module bundle and half-module
+ //TODO clean this up to a separate method
+ LongHalfModule halfModule;
+ HalfModuleBundle halfModuleBundle;
+ if(isAxial) {
+ halfModuleBundle = new LongHalfModuleBundle();
+ if(isHole) {
+ halfModule = new LongAxialHoleHalfModule(volName, mother, alignmentCorrection, layer, half);
+ bundle.halfModuleAxialHole = halfModuleBundle;
+ } else {
+ halfModule = createLongAxialSlotHalfModule(volName, mother, alignmentCorrection, layer, half);
+ bundle.halfModuleAxialSlot = halfModuleBundle;
+ }
+ } else {
+ halfModuleBundle = new LongHalfModuleBundle();
+ if(isHole) {
+ halfModule = new LongStereoHoleHalfModule(volName, mother, alignmentCorrection, layer, half);
+ bundle.halfModuleStereoHole = halfModuleBundle;
+ } else {
+ halfModule = createLongStereoSlotHalfModule(volName, mother, alignmentCorrection, layer, half);
+ bundle.halfModuleStereoSlot = halfModuleBundle;
+ }
+ }
+ halfModuleBundle.halfModule = halfModule;
+
+
+
+
+ // create the half module components
+ makeHalfModuleComponentSensor(halfModule);
+
+ makeLongHalfModuleComponentKapton(halfModule);
+
+ //makeHalfModuleComponentCF(halfModule);
+
+ //makeHalfModuleComponentHybrid(halfModule);
+
+
+
+
+ }
+
+
+ protected void makeLongHalfModuleComponentKapton(BaseModule mother) {
+
+ if(isDebug()) System.out.printf("%s: makeHalfModuleComponentKapton for %s \n", this.getClass().getSimpleName(), mother.getName());
+
+ String volName = mother.getName() + "_lamination";
+
+ // Build the half-module
+
+ // id is hard coded
+ int component_number = 2;
+
+ HalfLongModuleLamination lamination = new HalfLongModuleLamination(volName,mother,component_number);
+ lamination.setMaterial("Kapton");
+
+
+ HalfModuleBundle hm = getHalfModuleBundle((BaseModule) mother.getMother(), mother.getName());
+ hm.lamination = lamination;
+
+ }
+
+
+
+
+
+ protected HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule createTestRunHalfModuleAxial(String volName,
+ BaseModule mother, AlignmentCorrection alignmentCorrection,
+ int layer, String half) {
+ return new HalfModuleAxial(volName, mother, alignmentCorrection, layer, half);
+
+ }
+
+ protected HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule createTestRunHalfModuleStereo(String volName,
+ BaseModule mother, AlignmentCorrection alignmentCorrection,
+ int layer, String half) {
+ return new HalfModuleStereo(volName, mother, alignmentCorrection, layer, half);
+
+ }
+
+ /**
+ * Create {@link LongAxialSlotHalfModule} {@link SurveyVolume}.
+ * @param name
+ * @param mother
+ * @param alignmentCorrection
+ * @param layer
+ * @param half
+ * @return
+ */
+ protected LongHalfModule createLongAxialSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ return new LongAxialSlotHalfModule(name, mother, alignmentCorrection, layer, half);
+ }
+
+ /**
+ * Create {@link LongStereoSlotHalfModule} {@link SurveyVolume}.
+ * @param name
+ * @param mother
+ * @param alignmentCorrection
+ * @param layer
+ * @param half
+ * @return
+ */
+ protected LongHalfModule createLongStereoSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ return new LongStereoSlotHalfModule(name, mother, alignmentCorrection, layer, half);
+ }
+
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition#getHalfModuleBundle(org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BaseModule, java.lang.String)
+ */
+ protected HalfModuleBundle getHalfModuleBundle(BaseModule module, String halfModuleName) {
+ BaseModuleBundle moduleBundle = getModuleBundle(module);
+ HalfModuleBundle hm = null;
+ if(moduleBundle!=null) {
+ if( moduleBundle instanceof TestRunModuleBundle) {
+ TestRunModuleBundle mtr = (TestRunModuleBundle) moduleBundle;
+ if(halfModuleName.contains("axial")) {
+ hm = mtr.halfModuleAxial;
+ }
+ else if(halfModuleName.contains("stereo")) {
+ hm = mtr.halfModuleStereo;
+ }
+ else {
+ throw new RuntimeException("NO axial or stereo string found in half module bundle name " + halfModuleName);
+ }
+ }
+ else if(moduleBundle instanceof LongModuleBundle) {
+ LongModuleBundle longModuleBundle = (LongModuleBundle) moduleBundle;
+ if(halfModuleName.contains("axial")) {
+ if(halfModuleName.contains("hole")) {
+ hm = longModuleBundle.halfModuleAxialHole;
+ } else if(halfModuleName.contains("slot")) {
+ hm = longModuleBundle.halfModuleAxialSlot;
+ } else {
+ throw new RuntimeException("This half-module name \"" + halfModuleName + " \" is invalid. Need to contain hole or slot for this type.");
+ }
+ } else if(halfModuleName.contains("stereo")) {
+ if(halfModuleName.contains("hole")) {
+ hm = longModuleBundle.halfModuleStereoHole;
+ } else if(halfModuleName.contains("slot")) {
+ hm = longModuleBundle.halfModuleStereoSlot;
+ } else {
+ throw new RuntimeException("This half-module name \"" + halfModuleName + " \" is invalid. Need to contain hole or slot for this type.");
+ }
+ } else {
+ throw new RuntimeException("This half-module name \"" + halfModuleName + " \" is invalid. Need to contain axial or stereo.");
+ }
+ }
+ else {
+ throw new NotImplementedException("This type of module bundle is not implemented!?");
+ }
+ } else {
+ throw new RuntimeException("Couldn't find module " + module.getName() + " and layer " + module.getLayer() + " and half " + module.getHalf());
+ }
+ return hm;
+ }
+
+
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTrackerBuilder#getMillepedeLayer(java.lang.String)
+ */
+ public int getMillepedeLayer(String name) {
+
+ boolean isTopLayer = getHalfFromName(name).equals("top") ? true : false;
+
+ // find layer
+ int layer = getLayerFromVolumeName(name);
+
+ // axial or stereo
+ boolean isAxial = isAxialFromName(name);
+
+ // use default layer numbering for L1-3
+ if(layer<4) {
+ return getOldLayerDefinition(isTopLayer, layer, isAxial);
+ }
+
+ // hole or slot
+ boolean isHole = isHoleFromName(name);
+
+ return getMillepedeLayer(isTopLayer, layer, isAxial, isHole);
+
+ }
+
+
+
+ /**
+ * Definition relating the sensors and layer number used in millepede for this detector.
+ * @param isTopLayer
+ * @param layer
+ * @param isAxial
+ * @param isHole
+ * @return
+ */
+ public int getMillepedeLayer(boolean isTopLayer, int layer, boolean isAxial, boolean isHole) {
+ int l = -1;
+ // use default layer numbering for L1-3
+ if(layer<4) {
+ l = getOldLayerDefinition(isTopLayer, layer, isAxial);
+ } else {
+ // Scheme:
+ // For top modules axial layer is odd and stereo is even.
+ // Hole vs slot given by example below:
+ // e.g. top layer 4:
+ // axial - hole: 7
+ // axial - slot: 9
+ // stereo - hole: 8
+ // axial - slot: 10
+
+ l = 7 + (layer-4)*4;
+ int s = -1;
+ if(isTopLayer) {
+ s = 0;
+ if(isAxial) {
+ s += 0;
+ } else {
+ s += 1;
+ }
+ if(isHole) {
+ s += 0;
+ } else {
+ s += 2;
+ }
+ } else {
+ s = 0;
+ if(!isAxial) {
+ s += 0;
+ } else {
+ s += 1;
+ }
+ if(isHole) {
+ s += 0;
+ } else {
+ s += 2;
+ }
+ }
+ l = l + s;
+ }
+
+ if(l<0) throw new RuntimeException("Error getting the millepede layer.");
+
+ if(isDebug()) System.out.printf("%s: %s %d %s %s -> MP layer %d\n",getClass().getSimpleName(),isTopLayer?"top":"bottom", layer, isAxial?"axial":"stereo", isHole?"hole":"slot", l);
+
+
+ return l;
+ }
+
+
+
+
+}
+
+
+
+
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014JavaBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014JavaBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014JavaBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,202 @@
+/**
+ *
+ */
+package org.lcsim.geometry.compact.converter;
+
+import java.util.ArrayList;
+
+import org.jdom.Element;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.Sensor;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.LongHalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.LongModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.PSVacuumChamber;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.SvtBox;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.SvtBoxBasePlate;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.BaseModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.HalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TestRunModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TrackingVolume;
+
+
+/**
+ * Class used by java converter to build java run time objects for the detector
+ * It encapsulates and adds the LCDD specific information to the generic @HPSTestRunTracker2014Builder.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTracker2014JavaBuilder extends HPSTestRunTracker2014JavaBuilder {
+
+
+
+ /**
+ * Default constructor
+ * @param node
+ */
+ public HPSTracker2014JavaBuilder(boolean debugFlag, Element node) {
+ super(debugFlag, node);
+ }
+
+
+
+
+ /**
+ * Build the JAVA geometry objects from the geometry definition.
+ * @param trackingVolume - the reference volume.
+ */
+ public void build(ILogicalVolume trackingVolume) {
+
+ // build geometry
+ setBuilder(createGeometryDefinition(this._debug, node));
+
+ if(_builder==null) throw new RuntimeException("need to set builder class before calling build!");
+
+ if(isDebug()) System.out.printf("%s: build the base geometry objects\n", getClass().getSimpleName());
+
+ _builder.build();
+
+ if(isDebug()) System.out.printf("%s: DONE build the base geometry objects\n", getClass().getSimpleName());
+
+ if(isDebug()) System.out.printf("%s: build the JAVA geometry objects\n", getClass().getSimpleName());
+
+ // initialize the list to store a reference to each object
+ javaSurveyVolumes = new ArrayList<JavaSurveyVolume>();
+
+ // Go through the list of volumes to build that is created in the generic builder class
+ JavaSurveyVolume tracking = new JavaSurveyVolume(_builder.getSurveyVolume(TrackingVolume.class), trackingVolume);
+ add(tracking);
+ JavaSurveyVolume chamber = new JavaGhostSurveyVolume(_builder.getSurveyVolume(PSVacuumChamber.class), tracking);
+ add(chamber);
+ setBaseTrackerGeometry(new JavaSurveyVolume(_builder.getSurveyVolume(SvtBox.class), chamber,1));
+ add(getBaseTrackerGeometry());
+ JavaSurveyVolume svtBoxBasePlate = new JavaGhostSurveyVolume(_builder.getSurveyVolume(SvtBoxBasePlate.class), getBaseTrackerGeometry());
+ add(svtBoxBasePlate);
+
+
+ // build modules
+
+ if(isDebug()) System.out.printf("%s: build JAVA modules\n", getClass().getSimpleName());
+
+ // Loop over all modules created
+ for(BaseModuleBundle mod : _builder.modules) {
+ BaseModuleBundle m = mod;
+ if(isDebug()) {
+ System.out.printf("%s: build module %s (layer %d half %s)\n", getClass().getSimpleName(),m.module.getName(),m.getLayer(),m.getHalf());
+ m.print();
+ }
+
+ // Find the mother among the objects using its name, should probably have a better way...
+ String name_mother = m.getMother().getName();
+ JavaSurveyVolume mother = null;
+ for(JavaSurveyVolume g : javaSurveyVolumes) {
+ if(g.getName().equals(name_mother)) {
+ mother = g;
+ break;
+ }
+ }
+ // Check that it had a mother
+ if(mother==null) throw new RuntimeException("Cound't find mother to module " + m.module.getName());
+
+ if(isDebug()) System.out.printf("%s: found mother %s to module %s\n", getClass().getSimpleName(),mother.getName(),m.module.getName());
+
+ // put the module in the list of objects that will be added to LCDD
+ addModule(m, mother);
+
+ if(isDebug()) System.out.printf("%s: DONE build module %s\n", getClass().getSimpleName(), m.module.getName());
+
+
+ }
+
+ if(isDebug()) System.out.printf("%s: DONE build JAVA modules\n", getClass().getSimpleName());
+
+
+ System.out.printf("%s: Built %d JAVA geometry objects\n", getClass().getSimpleName(),javaSurveyVolumes.size());
+
+ if(isDebug()) {
+ System.out.printf("%s: DONE building the JAVA geometry objects\n", getClass().getSimpleName());
+ System.out.printf("%s: List of all the JAVA geometry objects built\n", this.getClass().getSimpleName());
+ for(JavaSurveyVolume bg : javaSurveyVolumes) {
+ System.out.printf("-------\n%s\n", bg.toString());
+ }
+ }
+
+
+ // Set visualization features
+ //setVis();
+
+
+ }
+
+ /**
+ * Rules for adding the JAVA module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother JAVA geometry object
+ */
+ private void addModule(BaseModuleBundle bundle, JavaSurveyVolume mother) {
+ if(bundle instanceof TestRunModuleBundle) {
+ addTestRunModule((TestRunModuleBundle) bundle, mother);
+ } else if(bundle instanceof LongModuleBundle) {
+ addLongModule((LongModuleBundle) bundle, mother);
+ } else {
+ throw new RuntimeException("The bundle is of unknown class type!");
+ }
+ }
+
+ /**
+ * Rules for adding the LCDD module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ private void addLongModule(LongModuleBundle bundle, JavaSurveyVolume mother) {
+ // This could perhaps be fixed if there is a relation with daughters in geometry definition?
+ // create the module
+ JavaSurveyVolume lcddM = new JavaGhostSurveyVolume(bundle.module, mother);
+ add(lcddM);
+ if(bundle.halfModuleAxialHole!=null) addLongHalfModule(bundle.halfModuleAxialHole,lcddM);
+ if(bundle.halfModuleAxialSlot!=null) addLongHalfModule(bundle.halfModuleAxialSlot,lcddM);
+ //if(bundle.coldBlock!=null) add(new LCDDSurveyVolume(bundle.coldBlock, lcdd, lcddM));
+ if(bundle.halfModuleStereoHole!=null) addLongHalfModule(bundle.halfModuleStereoHole,lcddM);
+ if(bundle.halfModuleStereoSlot!=null) addLongHalfModule(bundle.halfModuleStereoSlot,lcddM);
+ }
+
+
+
+ private void addLongHalfModule(HalfModuleBundle bundle2, JavaSurveyVolume mother) {
+ LongHalfModuleBundle bundle = (LongHalfModuleBundle) bundle2;
+ // Create the half-module
+ // This is not a ghost element but reflects the module
+ // concept in the old compact description
+ int oldCompactModuleId = 0;
+ JavaSurveyVolume lcddHM = new JavaSurveyVolume(bundle.halfModule, mother,oldCompactModuleId);
+ add(lcddHM);
+
+ // ComponentNumber is taken from old geometry where it is simply a counter when adding the xml daughters to the TestRunModule.
+ // It is simply 0 for sensor and 1 for carbon fiber in the old geometry
+ int componentNumber = ((Sensor)bundle.sensor).getId();
+
+ // create the sensor
+ JavaSurveyVolume lcddS = new JavaSurveyVolume(bundle.sensor, lcddHM, componentNumber);
+ add(lcddS);
+
+ // create the active sensor
+ JavaSurveyVolume lcddAS = new JavaSurveyVolume(bundle.activeSensor, lcddS, componentNumber);
+ add(lcddAS);
+
+// if(isDebug()) {
+// System.out.printf("%s: added sensor %s \n",this.getClass().getSimpleName(), lcddS.getName());
+// System.out.printf("%s: local coordinate system\n%s\n",this.getClass().getSimpleName(), bundle.sensor.getCoord().toString());
+// dsd
+// }
+
+
+ }
+
+ @Override
+ public HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug, Element node) {
+ return new HPSTracker2014GeometryDefinition(debug, node);
+ }
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014LCDDBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014LCDDBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014LCDDBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,246 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.LongHalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.LongModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.PSVacuumChamber;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.SvtBox;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.SvtBoxBasePlate;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL13Bottom;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL13BottomPlate;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL13Top;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL13TopPlate;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL46Bottom;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL46BottomPlate;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL46Top;
+import org.lcsim.geometry.compact.converter.HPSTracker2014GeometryDefinition.UChannelL46TopPlate;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.BaseModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder.HalfModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TestRunModuleBundle;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition.TrackingVolume;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+
+public class HPSTracker2014LCDDBuilder extends HPSTestRunTracker2014LCDDBuilder {
+
+ public HPSTracker2014LCDDBuilder(boolean debugFlag, Element node,
+ LCDD lcdd, SensitiveDetector sens) {
+
+ super(debugFlag, node, lcdd, sens);
+
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTestRunTracker2014LCDDBuilder#setBuilder()
+ */
+ public void setBuilder() {
+ setBuilder(createGeometryDefinition(_debug, node));
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.HPSTestRunTracker2014LCDDBuilder#build(org.lcsim.geometry.compact.converter.lcdd.util.Volume)
+ */
+ public void build(Volume worldVolume) {
+
+ // set and build geometry
+ setBuilder();
+
+ if(_builder==null) throw new RuntimeException("need to set builder class before calling build!");
+
+ if(isDebug()) System.out.printf("%s: build the base geometry objects\n", getClass().getSimpleName());
+
+ _builder.build();
+
+ if(isDebug()) System.out.printf("%s: DONE build the base geometry objects\n", getClass().getSimpleName());
+
+
+ if(isDebug()) System.out.printf("%s: build the LCDD geometry objects\n", getClass().getSimpleName());
+
+
+ LCDDSurveyVolume trackingGeometry = new LCDDSurveyVolume(_builder.getSurveyVolume(TrackingVolume.class), worldVolume);
+ add(trackingGeometry);
+
+// baseSurveyVolume = new LCDDSurveyVolume(_builder.getSurveyVolume(PSVacuumChamber.class), lcdd, trackingGeometry);
+// add(baseSurveyVolume);
+ LCDDSurveyVolume vacuumChamberVolume = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(PSVacuumChamber.class), trackingGeometry);
+ add(vacuumChamberVolume);
+
+// LCDDSurveyVolume svtBox = new LCDDSurveyVolume(_builder.getSurveyVolume(SvtBox.class), lcdd, baseSurveyVolume);
+// add(svtBox);
+
+ LCDDSurveyVolume svtBox = new LCDDSurveyVolume(_builder.getSurveyVolume(SvtBox.class), lcdd, vacuumChamberVolume);
+ baseSurveyVolume = svtBox;
+ add(baseSurveyVolume);
+
+
+ LCDDSurveyVolume svtBoxBasePlate = new LCDDSurveyVolume(_builder.getSurveyVolume(SvtBoxBasePlate.class), lcdd, svtBox);
+ add(svtBoxBasePlate);
+
+
+ LCDDSurveyVolume uChannelL13Bottom = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(UChannelL13Bottom.class), svtBox);
+ add(uChannelL13Bottom);
+
+ LCDDSurveyVolume uChannelL13BottomPlate = new LCDDSurveyVolume(_builder.getSurveyVolume(UChannelL13BottomPlate.class), lcdd, svtBox);
+ add(uChannelL13BottomPlate);
+
+ LCDDSurveyVolume uChannelL13Top = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(UChannelL13Top.class), svtBox);
+ add(uChannelL13Top);
+
+ LCDDSurveyVolume uChannelL13TopPlate = new LCDDSurveyVolume(_builder.getSurveyVolume(UChannelL13TopPlate.class), lcdd, svtBox);
+ add(uChannelL13TopPlate);
+
+ LCDDSurveyVolume uChannelL46Bottom = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(UChannelL46Bottom.class), svtBox);
+ add(uChannelL46Bottom);
+
+ LCDDSurveyVolume uChannelL46BottomPlate = new LCDDSurveyVolume(_builder.getSurveyVolume(UChannelL46BottomPlate.class), lcdd, svtBox);
+ add(uChannelL46BottomPlate);
+
+ LCDDSurveyVolume uChannelL46Top = new LCDDGhostSurveyVolume(_builder.getSurveyVolume(UChannelL46Top.class), svtBox);
+ add(uChannelL46Top);
+
+ LCDDSurveyVolume uChannelL46TopPlate = new LCDDSurveyVolume(_builder.getSurveyVolume(UChannelL46TopPlate.class), lcdd, svtBox);
+ add(uChannelL46TopPlate);
+
+
+ // build modules
+
+ if(isDebug()) System.out.printf("%s: build modules\n", getClass().getSimpleName());
+
+ // Loop over all modules created
+ for(BaseModuleBundle mod : _builder.modules) {
+ //SVTModuleBundle m = (SVTModuleBundle) mod;
+ BaseModuleBundle m = mod;
+ if(isDebug()) {
+ System.out.printf("%s: module layer %d half %s\n", getClass().getSimpleName(),m.getLayer(),m.getHalf());
+ m.print();
+ }
+
+ // Find the mother among the LCDD objects using its name, should probably have a better way...
+ String name_mother = m.getMother().getName();
+ LCDDSurveyVolume mother = null;
+ for(LCDDSurveyVolume g : lcddSurveyVolumes) {
+ if(g.getName().equals(name_mother)) {
+ mother = g;
+ break;
+ }
+ }
+ // Check that it had a mother
+ if(mother==null) throw new RuntimeException("Cound't find mother to module layer " + m.getLayer() + " half "+ m.getHalf());
+
+ if(isDebug()) System.out.printf("%s: found mother %s for module layer %d half %s\n", getClass().getSimpleName(),mother.getName(),m.getLayer(),m.getHalf());
+
+ // add the module to the list of objects that will be added to LCDD
+ addModule(m, mother);
+
+ }
+
+
+
+
+ System.out.printf("%s: Built %d LCDD geometry objects\n", getClass().getSimpleName(), lcddSurveyVolumes.size());
+
+ if(isDebug()) {
+ System.out.printf("%s: List of all %d LCDD geometry objects built\n", this.getClass().getSimpleName(), lcddSurveyVolumes.size());
+ for(SurveyVolumeImpl bg : lcddSurveyVolumes) {
+ System.out.printf("-------\n%s\n", bg.toString());
+ }
+ }
+
+
+
+ // Set visualization features
+ setVisualization();
+
+ }
+
+ /**
+ * Rules for adding the LCDD module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ private void addModule(BaseModuleBundle bundle, LCDDSurveyVolume mother) {
+ if(bundle instanceof TestRunModuleBundle) {
+ addTestRunModule((TestRunModuleBundle) bundle, mother);
+ } else if(bundle instanceof LongModuleBundle) {
+ addLongModule((LongModuleBundle) bundle, mother);
+ } else {
+ throw new RuntimeException("The bundle is of unknown class type!");
+ }
+ }
+
+ /**
+ * Rules for adding the LCDD module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ protected void addLongModule(LongModuleBundle bundle, LCDDSurveyVolume mother) {
+ LCDDSurveyVolume lcddM = new LCDDGhostSurveyVolume(bundle.module, mother);
+ //LCDDSurveyVolume lcddM = new LCDDSurveyVolume(bundle.module, lcdd, mother);
+ add(lcddM);
+ if(bundle.halfModuleAxialHole!=null) addLongHalfModule(bundle.halfModuleAxialHole,lcddM);
+ if(bundle.halfModuleAxialSlot!=null) addLongHalfModule(bundle.halfModuleAxialSlot,lcddM);
+ if(bundle.coldBlock!=null) add(new LCDDSurveyVolume(bundle.coldBlock, lcdd, lcddM));
+ if(bundle.halfModuleStereoHole!=null) addLongHalfModule(bundle.halfModuleStereoHole,lcddM);
+ if(bundle.halfModuleStereoSlot!=null) addLongHalfModule(bundle.halfModuleStereoSlot,lcddM);
+ }
+
+
+
+ /**
+ * Rules for adding the LCDD module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ protected void addTestRunModule(TestRunModuleBundle bundle, LCDDSurveyVolume mother) {
+ // This could perhaps be fixed if there is a relation with daughters in geometry definition?
+ // create the module
+ LCDDSurveyVolume lcddM = new LCDDGhostSurveyVolume(bundle.module, mother);
+ //SurveyVolume(bundle.module, lcdd, mother);
+ add(lcddM);
+ if(bundle.halfModuleAxial!=null) addTestRunHalfModule(bundle.halfModuleAxial,lcddM);
+ if(bundle.coldBlock!=null) add(new LCDDSurveyVolume(bundle.coldBlock, lcdd, lcddM));
+ if(bundle.halfModuleStereo!=null) addTestRunHalfModule((TestRunHalfModuleBundle)bundle.halfModuleStereo,lcddM);
+ }
+
+
+
+ /**
+ * Rules for adding the LCDD half module geometry.
+ * @param bundle - module to be added
+ * @param mother - mother LCDD geometry object
+ */
+ private void addLongHalfModule(HalfModuleBundle bundle2, LCDDSurveyVolume mother) {
+ LongHalfModuleBundle bundle = (LongHalfModuleBundle) bundle2;
+
+ // create the half-module
+ LCDDSurveyVolume lcddHM = new LCDDSurveyVolume(bundle.halfModule, lcdd, mother);
+ add(lcddHM);
+ // create the sensor
+ LCDDSurveyVolume lcddS = new LCDDSurveyVolume(bundle.sensor, lcdd, lcddHM);
+ add(lcddS);
+ // create the active sensor
+ LCDDSurveyVolume lcddAS = new LCDDSurveyVolume(bundle.activeSensor, lcdd, lcddS);
+ add(lcddAS);
+ // create the lamination
+ LCDDSurveyVolume lcddL = new LCDDSurveyVolume(bundle.lamination, lcdd, lcddHM);
+ add(lcddL);
+ /*
+ // create the carbon fiber frame
+ LCDDSurveyVolume lcddCF = new LCDDSurveyVolume(bundle.carbonFiber, lcdd, lcddHM);
+ add(lcddCF);
+ // create the hybrid frame
+ LCDDSurveyVolume lcddH = new LCDDSurveyVolume(bundle.hybrid, lcdd, lcddHM);
+ add(lcddH);
+*/
+ }
+
+ @Override
+ public HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug,
+ Element node) {
+ return new HPSTracker2014GeometryDefinition(_debug, node);
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1GeometryDefinition.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1GeometryDefinition.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1GeometryDefinition.java Tue May 5 14:05:24 2015
@@ -0,0 +1,105 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import org.jdom.Element;
+
+/**
+ *
+ * Updated geometry information for the HPS tracker 2014
+
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class HPSTracker2014v1GeometryDefinition extends HPSTracker2014GeometryDefinition {
+
+ public HPSTracker2014v1GeometryDefinition(boolean debug, Element node) {
+ super(debug, node);
+ }
+
+ public static class LongAxialSlotHalfModule extends HPSTracker2014GeometryDefinition.LongAxialSlotHalfModuleBase {
+
+ public LongAxialSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer,
+ String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+
+ @Override
+ protected void applyGenericCoordinateSystemCorrections() {
+
+ super.applyGenericCoordinateSystemCorrections();
+
+ // apply 180 degree rotation around w to get hybrid on the correct side
+
+ if(debug) {
+ System.out.printf("%s: Coord before corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ System.out.printf("%s: box center before corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ }
+ getCoord().rotateApache(getSlotRotation());
+
+ if(debug) {
+ System.out.printf("%s: Coord after corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ System.out.printf("%s: box center after corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ }
+ }
+ }
+
+ public static class LongStereoSlotHalfModule extends HPSTracker2014GeometryDefinition.LongStereoSlotHalfModuleBase {
+
+ public LongStereoSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection, int layer, String half) {
+ super(name, mother, alignmentCorrection, layer, half);
+ init();
+ }
+
+ @Override
+ protected void applyGenericCoordinateSystemCorrections() {
+
+ super.applyGenericCoordinateSystemCorrections();
+
+ if(debug) {
+ System.out.printf("%s: v1 LongStereoSlotHalfModule Generic Corrections\n", getClass().getSimpleName());
+ System.out.printf("%s: Coord before corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ System.out.printf("%s: box center before corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ }
+
+ getCoord().rotateApache(getSlotRotation());
+
+ if(debug) {
+ System.out.printf("%s: Coord after corrections\n%s\n", getClass().getSimpleName(),getCoord().toString());
+ System.out.printf("%s: box center after corrections\n%s\n", getClass().getSimpleName(),getBoxDim().toString());
+ }
+ }
+
+
+ }
+
+ @Override
+ protected LongHalfModule createLongAxialSlotHalfModule(String name, SurveyVolume mother,
+ AlignmentCorrection alignmentCorrection,
+ int layer, String half) {
+ return new LongAxialSlotHalfModule(name, mother, alignmentCorrection, layer, half);
+ }
+
+ @Override
+ protected LongHalfModule createLongStereoSlotHalfModule(String name,
+ SurveyVolume mother, AlignmentCorrection alignmentCorrection,
+ int layer, String half) {
+
+ return new LongStereoSlotHalfModule(name, mother, alignmentCorrection, layer, half);
+ }
+
+
+ /**
+ * PI rotation around generic z-axis
+ * @return
+ */
+ private static Rotation getSlotRotation() {
+ return new Rotation(new Vector3D(0,0,1),Math.PI);
+ }
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1JavaBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1JavaBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1JavaBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,17 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.jdom.Element;
+
+public class HPSTracker2014v1JavaBuilder extends HPSTracker2014JavaBuilder {
+
+ public HPSTracker2014v1JavaBuilder(boolean debugFlag, Element node) {
+ super(debugFlag, node);
+ }
+
+ @Override
+ public HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug, Element node) {
+ return new HPSTracker2014v1GeometryDefinition(debug, node);
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1LCDDBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1LCDDBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTracker2014v1LCDDBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,23 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+
+public class HPSTracker2014v1LCDDBuilder extends HPSTracker2014LCDDBuilder {
+
+ public HPSTracker2014v1LCDDBuilder(boolean debugFlag, Element node,
+ LCDD lcdd, SensitiveDetector sens) {
+ super(debugFlag, node, lcdd, sens);
+ }
+
+ public void setBuilder() {
+ setBuilder(createGeometryDefinition(_debug, node));
+ }
+
+ @Override
+ public HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug,
+ Element node) {
+ return new HPSTracker2014v1GeometryDefinition(_debug, node);
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,556 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.jdom.DataConversionException;
+import org.jdom.Element;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BaseModule;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule;
+
+public abstract class HPSTrackerBuilder {
+
+ private boolean debug = true;
+ public List<BaseModuleBundle> modules = new ArrayList<BaseModuleBundle>();
+ protected List<SurveyVolume> surveyVolumes = new ArrayList<SurveyVolume>();
+ protected Element node;
+ protected List<MilleParameter> milleparameters = new ArrayList<MilleParameter>();
+
+
+
+ /**
+ * Default constructor to create a geometry.
+ * @param debug output flag
+ * @param node to have access to compact xml
+ */
+ public HPSTrackerBuilder(boolean debug, Element node) {
+ this.debug = debug;
+ this.node = node;
+ initAlignmentParameters();
+ }
+
+ /**
+ * Extract alignment constants from xml description
+ */
+ private void initAlignmentParameters() {
+
+ if(debug) System.out.printf("%s: initAlignmentParameters from %s\n",this.getClass().getSimpleName(),node.getAttributeValue("name"));
+
+ // Get alignment parameters.
+ int detId=-1;
+ try {
+ detId = node.getAttribute("id").getIntValue();
+ } catch (DataConversionException e) {
+ e.printStackTrace();
+ }
+ String detName = node.getAttributeValue("name");
+ String detType = node.getAttributeValue("type");
+
+ Element constantsElement = node.getChild("millepede_constants");
+ if(constantsElement==null) {
+ throw new RuntimeException("no millepede constants found in compact file");
+ }
+
+ if(debug) System.out.printf("%s: %d alignment corrections for detId=%d detName=%s detType=%s\n",this.getClass().getSimpleName(),constantsElement.getChildren("millepede_constant").size(),detId,detName,detType);
+
+ int id = -99999;
+ double value=-99999;
+ for(Iterator iConstant = constantsElement.getChildren("millepede_constant").iterator(); iConstant.hasNext();) {
+ Element constantElement = (Element)iConstant.next();
+ try {
+ id = constantElement.getAttribute("name").getIntValue();
+ value = constantElement.getAttribute("value").getDoubleValue();
+ } catch (DataConversionException e) {
+ e.printStackTrace();
+ }
+ //System.out.printf("%s: constant %d value %f\n",this.getClass().getSimpleName(),id,value);
+
+ MilleParameter p = new MilleParameter(id,value,0.0);
+ //System.out.printf("%s: Milleparameter: %s\n", this.getClass().getSimpleName(),p.toString());
+ milleparameters.add(p);
+
+ }
+
+ if(debug) {
+ System.out.printf("%s: Initialized %d alignment parameters:\n",this.getClass().getSimpleName(),milleparameters.size());
+ for(MilleParameter p: milleparameters) {
+ System.out.printf("%s: %s \n",this.getClass().getSimpleName(),p.toString());
+ }
+ }
+
+ }
+
+
+ /**
+ * Extract @AlignmentCorrection for a half-module
+ * @param isTopLayer - top or bottom layer
+ * @param layer - to identify which sensor it is.
+ * @return the alignment correction for this half-module
+ */
+ protected AlignmentCorrection getHalfModuleAlignmentCorrection(boolean isTopLayer, int layer) {
+ int rFound = 0;
+ int tFound = 0;
+ double r[] = {0,0,0};
+ double t[] = {0,0,0};
+ for(MilleParameter p_loop: milleparameters) {
+ boolean paramIsTop = p_loop.getHalf()==1?true:false;
+ int paramLayer = p_loop.getSensor();
+ if(paramIsTop==isTopLayer && paramLayer==layer) {
+ if(p_loop.getType()==1) {
+ t[p_loop.getDim()-1] = p_loop.getValue();
+ tFound++;
+ } else if(p_loop.getType()==2) {
+ r[p_loop.getDim()-1] = p_loop.getValue();
+ rFound++;
+ }
+ }
+ }
+ if(tFound!=3 || rFound!=3) {
+ throw new RuntimeException("Problem finding translation alignment parameters (found t " + tFound + " r " + rFound + ") for " + (isTopLayer?"top":"bottom") + " layer " + layer);
+ }
+ AlignmentCorrection c = new AlignmentCorrection();
+ c.setTranslation(new BasicHep3Vector(t));
+ c.setRotation(r[0],r[1],r[2]);
+ return c;
+ }
+
+ /**
+ * Extract @AlignmentCorrection for the support
+ * @param isTopLayer - top or bottom layer
+ * @return the alignment correction
+ */
+ protected AlignmentCorrection getSupportAlignmentCorrection(boolean isTopLayer) {
+ double r[] = {0,0,0};
+ double t[] = {0,0,0};
+ for(MilleParameter p_loop: milleparameters) {
+ boolean paramIsTop = p_loop.getHalf()==1?true:false;
+ if(paramIsTop==isTopLayer && p_loop.getType()==3) {
+ //xcheck
+ if(p_loop.getSensor()!=0) throw new RuntimeException("sensor name is not zero for support plate param! " + p_loop.getSensor());
+ // get the correction
+ r[p_loop.getDim()-1] = p_loop.getValue();
+ }
+ }
+ AlignmentCorrection c = new AlignmentCorrection();
+ c.setTranslation(new BasicHep3Vector(t));
+ c.setRotation(r[0],r[1],r[2]);
+ return c;
+ }
+
+
+
+ /**
+ * Build the local geometry
+ *
+ */
+ public abstract void build();
+
+
+
+
+
+ /**
+ * Bundle volumes into a module.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public abstract static class BaseModuleBundle {
+ public SurveyVolume module = null;
+ public BaseModuleBundle(BaseModule m) {
+ module = m;
+ }
+ public int getLayer() {
+ if(module==null) throw new RuntimeException("Need to add module to bundle first!");
+ return HPSTrackerBuilder.getLayerFromVolumeName(module.getName());
+ }
+ public String getHalf() {
+ if(module==null) throw new RuntimeException("Need to add module to bundle first!");
+ return HPSTrackerBuilder.getHalfFromName(module.getName());
+ }
+ public SurveyVolume getMother() {
+ if(module==null) throw new RuntimeException("Need to add module to bundle first!");
+ return module.getMother();
+ }
+ public abstract void print();
+ }
+
+ /**
+ * Bundle volumes into a half-module.
+ * TODO If the geometry definition has access to daughter information I could avoid this?
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static abstract class HalfModuleBundle {
+ public SurveyVolume halfModule = null;
+ public SurveyVolume lamination = null;
+ public SurveyVolume sensor = null;
+ public SurveyVolume activeSensor = null;
+ public HalfModuleBundle(SurveyVolume hm) {
+ halfModule = hm;
+ }
+ public HalfModuleBundle() {
+ }
+ public void print() {
+ if(halfModule!=null) System.out.printf("%s: %s\n", this.getClass().getSimpleName(),halfModule.toString());
+ if(activeSensor!=null) System.out.printf("%s: %s\n", this.getClass().getSimpleName(),activeSensor.toString());
+ }
+ }
+
+
+ public static String getHalfFromName(String name) {
+ String half = "";
+ if(name.contains("bottom")) {
+ half = "bottom";
+ }
+ if(name.contains("top")) {
+ // check that both sides are not found
+ if(half.equals("bottom")) {
+ throw new RuntimeException("found both halfs from name " + name);
+ } else {
+ half = "top";
+ }
+ }
+ // check for other signatures
+ if( half.isEmpty()) {
+ // 6 layers is arbitrary here
+ for(int layer=1;layer<=6;++layer) {
+ if(name.contains(String.format("L%db", layer))) {
+ half = "bottom";
+ break;
+ }
+ if(name.contains(String.format("L%dt", layer))) {
+ if(half.equals("bottom")) {
+ throw new RuntimeException("found both halfs from name " + name);
+ }
+ half = "top";
+ break;
+ }
+ }
+ }
+ if( half.isEmpty()) {
+ System.out.println("found no half from " + name);
+ throw new RuntimeException("found no half from " + name);
+ } else {
+ return half;
+
+ }
+ }
+
+ public static int getLayerFromVolumeName(String name) {
+ int layer = -1;
+ for(int i=1; i<= 6; ++i) {
+ if(name.contains(String.format("module_L%d", i))) {
+ layer = i;
+ }
+ }
+ if( layer == -1) {
+ System.out.println("cannot find layer from " + name);
+ System.exit(1);
+ }
+ return layer;
+ }
+
+ public static boolean isBase(String name) {
+ if(name.endsWith("base")) {
+ return true;
+ }
+ return false;
+ }
+
+ public static boolean isHalfModule(String name) {
+ if(name.endsWith("halfmodule_axial") ||
+ name.endsWith("halfmodule_axial_slot") ||
+ name.endsWith("halfmodule_axial_hole") ||
+ name.endsWith("halfmodule_stereo") ||
+ name.endsWith("halfmodule_stereo_slot") ||
+ name.endsWith("halfmodule_stereo_hole"
+ )) {
+ return true;
+ }
+ return false;
+ }
+
+ public static boolean isSensor(String name) {
+ if(name.endsWith("sensor")) {
+ return true;
+ }
+ return false;
+ }
+
+ public static boolean isActiveSensor(String name) {
+ if(name.endsWith("sensor_active")) {
+ return true;
+ }
+ return false;
+ }
+
+
+
+ protected boolean isDebug() {
+ return debug;
+ }
+
+ protected void setDebug(boolean debug) {
+ this.debug = debug;
+ }
+
+ /**
+ * Find geometry object by type.
+ * @param c - class type to be found
+ * @return the found type.
+ */
+ public <T> T getSurveyVolume(Class<T> c) {
+ //if(isDebug()) System.out.printf("%s: get Item %s\n", this.getClass().getSimpleName(),c.getName());
+
+ for(SurveyVolume item : surveyVolumes) {
+ //if(isDebug()) System.out.printf("%s: item %s\n", getClass().getSimpleName(),item.getClass().getName());
+ if(c.isInstance(item)) {
+ return (T)item;
+ }
+ }
+ throw new RuntimeException("Coulnd't find instance of " + c.getSimpleName() + " among the " + surveyVolumes.size() + " tracker items!");
+ }
+
+ protected List<BaseModuleBundle> getModules() {
+ return modules;
+ }
+
+ /**
+ * Find module among the existing bundles.
+ * @param layer - layer id
+ * @param half - top or bottom half
+ * @return module or null if not found
+ */
+ protected BaseModuleBundle getModuleBundle(int layer, String half) {
+ for(BaseModuleBundle m : modules) {
+ if(m.getLayer()==layer && m.getHalf().equals(half)) {
+ return m;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Find module among the existing bundles.
+ * @param module - to find
+ * @return bundle
+ */
+ protected BaseModuleBundle getModuleBundle(BaseModule module) {
+ return getModuleBundle(module.getLayer(), module.getHalf());
+ }
+
+
+ /**
+ * Add module to list.
+ * @param bundle - module to add.
+ */
+ protected void addModuleBundle(BaseModuleBundle bundle) {
+ BaseModuleBundle b = getModuleBundle(bundle.getLayer(), bundle.getHalf());
+ if(b==null) {
+ modules.add(bundle);
+ } else {
+ throw new RuntimeException("There is already a module bundle with layer " + bundle.getLayer() + " and half " + bundle.getHalf());
+ }
+ }
+
+ /**
+ * Checks if the orientation of the sensor is axial.
+ * Uses the moduleId definition from the "old" geometry for
+ * consistency.
+ *
+ * @return true if it is, false if it is a stereo sensor
+ */
+ public static boolean isAxial(boolean isTopLayer, int layer) {
+ if (isTopLayer && layer % 2 == 1) {
+ return true;
+ } else if (!isTopLayer && layer % 2 == 0) {
+ return true;
+ }
+ return false;
+ }
+
+
+
+ /**
+ * Find transform to parent volume coordinate system.
+ * @param t - current transform to mother
+ * @param mother - geometry object from current transform
+ * @param targetMotherName - parent volume defining new vector coordinate system
+ * @return transform.
+ */
+ public static Transform3D getTransform(Transform3D t, SurveyVolume mother, String targetMotherName) {
+ int debug=0;
+ if(debug>0) System.out.printf("getTransform mother %s target %s with current transform\n%s\n", mother.getName(), targetMotherName,t.toString());
+ if(mother==null) throw new RuntimeException("Trying to get mother transform but there is no mother?!");
+ if(mother.getName().equals(targetMotherName)) {
+ if(debug>0) System.out.printf("found the transform\n");
+ return t;
+ } else {
+ if(debug>0) System.out.printf("add mother transform\n%s\n",mother.getCoord().getTransformation().toString());
+ Transform3D trans = Transform3D.multiply(mother.getCoord().getTransformation(), t);
+ if(debug>0) System.out.printf("resulting transform\n%s\ncontinue searching\n",trans.toString());
+ return getTransform(trans, mother.getMother(), targetMotherName);
+ }
+
+ }
+
+ /**
+ * Find the vector in a parent volume coordinate system.
+ * @param vec - vector to transform
+ * @param geometry - geometry where vector is defined.
+ * @param targetMotherName - parent volume defining new vector coordinate system
+ * @return transformed vector.
+ */
+ public static Hep3Vector transformToMotherCoord(Hep3Vector vec, SurveyVolume geometry, String targetMotherName) {
+ int debug =0;
+ SurveyVolume mother = geometry.getMother();
+ if(debug>0) System.out.printf("transformToMotherCoord vec %s geomtry %s mother %s target %s\n", vec.toString(), geometry.getName(), geometry.getMother().getName(), targetMotherName);
+
+ Transform3D t = getTransform(geometry.getCoord().getTransformation(), mother, targetMotherName);
+
+ Hep3Vector vec_t = t.transformed(vec);
+
+ if(debug>0) {
+ System.out.printf("transformToMotherCoord apply transform \n%s\n",t.toString());
+ System.out.printf("transformToMotherCoord vec_t%s\n",vec_t.toString());
+ }
+
+
+ return vec_t;
+ }
+
+ /**
+ * Find the vector in the tracking volume coordinate system.
+ * @param vec - vector to transform
+ * @param geometry - geometry where vector is defined.
+ * @return transformed vector.
+ */
+ public static Hep3Vector transformToTracking(Hep3Vector vec, SurveyVolume geometry) {
+ return transformToParent(vec, geometry, "trackingVolume");
+ }
+
+ /**
+ * Find the vector in a mother volume coordinate system.
+ * @param vec - vector to transform
+ * @param geometry - geometry where vector is defined.
+ * @return transformed vector.
+ */
+ public static Hep3Vector transformToParent(Hep3Vector vec, SurveyVolume geometry, String targetName) {
+ int debug = 0;
+ if(debug>0) System.out.printf("\ntransformToParent: vec %s in local coordiantes of %s\n", vec.toString(), geometry.getName());
+ if(geometry.getMother()==null) {
+ if(debug>0) System.out.printf("\ntransformToParent: no mother, return null\n", vec.toString(), geometry.getName());
+ return null;
+ }
+ if(debug>0) System.out.printf("\ntransformToParent: vec %s in local coordiantes of %s with mother %s\n", vec.toString(), geometry.getName(), geometry.getMother().getName().toString());
+ SurveyCoordinateSystem coord = geometry.getCoord();
+ if(coord==null) {
+ throw new RuntimeException("transformToParent: no coordinate system found for %s, return null " + geometry.getName());
+ }
+ Hep3Vector vec_mother_coord = coord.getTransformation().transformed(vec);
+ if(debug>0) System.out.printf("vec_mother_coord %s\n",vec_mother_coord.toString());
+ if(geometry.getMother().getName().equals(targetName)) {
+ if(debug>0) System.out.printf("reached target \"%s\"tracking volume. Return \n", targetName);
+ return vec_mother_coord;
+ } else {
+ if(debug>0) System.out.printf("continue searching.\n");
+ }
+ return transformToParent(vec_mother_coord, geometry.getMother(), targetName);
+ }
+
+
+
+
+
+
+ /**
+ * Get axial or stereo key name from string
+ * @param name
+ * @return axial or not boolean
+ */
+ public static boolean isAxialFromName(String name) {
+ boolean isAxial;
+ if(name.contains("axial")) isAxial=true;
+ else if(name.contains("stereo")) isAxial=false;
+ else throw new RuntimeException("no axial or stereo name found from " + name);
+ return isAxial;
+ }
+
+ /**
+ * Get hole or slot key name from string
+ * @param name.
+ * @return hole or not boolean
+ */
+ public static boolean isHoleFromName(String name) {
+ boolean isHole;
+ if(name.contains("hole")) isHole=true;
+ else if(name.contains("slot")) isHole=false;
+ else throw new RuntimeException("no hole or slot keys found in name " + name);
+ return isHole;
+ }
+
+
+ /**
+ * Extract old definition of Test Run sensor number.
+ * @param isTopLayer - top or bottom layer
+ * @param l - layer
+ * @param isAxial - axial or stereo sensor
+ * @return
+ */
+ public int getOldGeomDefLayerFromVolumeName(String name) {
+
+ String half = getHalfFromName(name);
+ int l = getLayerFromVolumeName(name);
+ boolean isTopLayer = false;
+ if(half=="top") isTopLayer=true;
+ else if(half=="bottom") isTopLayer = false;
+ else throw new RuntimeException("no half found from " + name);
+ boolean isAxial = isAxialFromName(name);
+ return getOldLayerDefinition(isTopLayer, l, isAxial);
+ }
+
+
+ /**
+ * Get the layer number consistent with the old geometry definition.
+ * @param module name that contains layer and half information.
+ * @return the layer.
+ */
+ public int getOldLayerDefinition(boolean isTopLayer, int l, boolean isAxial) {
+ int layer=-1;
+ if(isAxial) {
+ if(isTopLayer) {
+ layer = 2*l-1;
+ }
+ else {
+ layer = 2*l;
+ }
+ } else {
+ if(isTopLayer) {
+ layer = 2*l;
+ } else {
+ layer = 2*l-1;
+ }
+ }
+ return layer;
+ }
+
+ /**
+ * Definition of the millepede layer number.
+ * @param name of half-module or sensor
+ * @return millepede layer number.
+ */
+ abstract public int getMillepedeLayer(String name);
+
+
+
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerGeometryDefinition.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerGeometryDefinition.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerGeometryDefinition.java Tue May 5 14:05:24 2015
@@ -0,0 +1,311 @@
+/**
+ *
+ */
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.ActiveSensor;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.BaseModule;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.CarbonFiber;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.HalfModuleLamination;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.Hybrid;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.Sensor;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModule;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition.TestRunHalfModuleBundle;
+
+/**
+ *
+ * Common geometry information for the HPS trackers
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+abstract public class HPSTrackerGeometryDefinition extends HPSTrackerBuilder {
+
+
+
+ //steering
+ public boolean doAxial = true;
+ public boolean doStereo = true;
+ public boolean doColdBlock = false;
+ public boolean doBottom = true;
+ public boolean doTop = true;
+ public int layerBitMask = 0x1; //0x1;//
+
+
+ //General
+ static final double inch = 25.4; //mm
+ protected static final boolean useSiStripsConvention = true;
+ protected static final boolean use30mradRotation = true;
+ protected static final boolean useFakeHalfModuleAxialPos = false;
+
+ // Global position references
+ protected static final double target_pos_wrt_base_plate_x = 162.3; //from Marco's 3D model
+ protected static final double target_pos_wrt_base_plate_y = 80.55; //from Tim's sketchup //68.75; //from Marco's 3D model
+ protected static final double target_pos_wrt_base_plate_z = 926.59; //from Marco's 3D model
+ protected static final double PS_vac_box_inner_height = 7.0*inch;
+ protected static final double PS_vac_box_inner_width = 16.38*inch;
+ // Inner length of the vacuum box is defined here until the horizontal fan-out.
+ // It's a little random as I'm actually not creating a volume for it here and thus
+ // it just needs to capture the SVT box.
+ protected static final double PS_vac_box_inner_length = 53.4*inch;
+
+
+
+ public HPSTrackerGeometryDefinition(boolean debug, Element node) {
+ super(debug, node);
+ }
+
+
+ protected abstract HalfModuleBundle getHalfModuleBundle(BaseModule module, String halfModuleName);
+ protected abstract void makeModuleBundle(int layer, String half);
+ protected abstract TestRunHalfModule createTestRunHalfModuleAxial(String volName, BaseModule mother, AlignmentCorrection alignmentCorrection, int layer, String half);
+ protected abstract TestRunHalfModule createTestRunHalfModuleStereo(String volName, BaseModule mother, AlignmentCorrection alignmentCorrection, int layer, String half);
+
+
+
+
+ protected boolean doLayer(int layer) {
+ int a = (1<<(layer-1)) & layerBitMask;
+ return a!=0?true:false;
+ }
+
+
+
+
+ /**
+ * Create the half-module.
+ * @param side - stereo or axial
+ * @param mother to the half-module
+ */
+ protected void makeHalfModule(String side, BaseModule mother) {
+
+ String moduleName = mother.getName();
+
+ if(isDebug()) System.out.printf("%s: makeHalfModule for %s %s \n", this.getClass().getSimpleName(), moduleName, side);
+
+ String volName = moduleName + "_halfmodule_" + side;
+
+ // top or bottom?
+ String half = mother.getHalf();
+ boolean isTopLayer = !mother.isBottom();
+
+ // find layer
+ int layer = mother.getLayer();
+
+ // axial or stereo
+ boolean isAxial = isAxialFromName(volName);
+
+ // find layer according to old definition
+ int millepedeLayer = getMillepedeLayer(volName);
+
+ //if(isDebug()) System.out.printf("%s: half? %s layer %d oldlayer %d axial? %s\n",
+ // this.getClass().getSimpleName(), isTopLayer?"top":"bottom", layer,oldLayer,isAxial?"yes":"no");
+
+ // find alignment correction to this volume
+ AlignmentCorrection alignmentCorrection = getHalfModuleAlignmentCorrection(isTopLayer, millepedeLayer);
+
+
+ // find the module bundle that it will be added to
+ //TestRunModuleBundle bundle = (TestRunModuleBundle)getModuleBundle(mother);
+ //TestRunHalfModuleBundle halfModuleBundle;
+ TestRunModuleBundle bundle = (TestRunModuleBundle) getModuleBundle(mother);
+ if(bundle==null) {
+ throw new RuntimeException("Couldn't find bundle for " + volName + " from mother " + mother.getName());
+ }
+
+ // Build the half-module bundle and add the half-module to it
+ HalfModuleBundle halfModuleBundle;
+ TestRunHalfModule halfModule;
+ if(isAxial) {
+ halfModule = createTestRunHalfModuleAxial(volName, mother, alignmentCorrection, layer, half);
+ halfModuleBundle = new TestRunHalfModuleBundle(halfModule);
+ bundle.halfModuleAxial = halfModuleBundle;
+ } else {
+ halfModule = createTestRunHalfModuleStereo(volName, mother, alignmentCorrection, layer, half);
+ halfModuleBundle = new TestRunHalfModuleBundle(halfModule);
+ bundle.halfModuleStereo = halfModuleBundle;
+ }
+
+
+ // create the half module components
+
+ makeHalfModuleComponentSensor(halfModule);
+
+ makeHalfModuleComponentKapton(halfModule);
+
+ makeHalfModuleComponentCF(halfModule);
+
+ makeHalfModuleComponentHybrid(halfModule);
+
+
+
+
+ }
+
+
+
+
+ void makeHalfModuleComponentHybrid(TestRunHalfModule mother) {
+
+ if(isDebug()) System.out.printf("%s: makeHalfModuleComponentHybrid for %s \n", this.getClass().getSimpleName(), mother.getName());
+
+ String volName = mother.getName() + "_hybrid";
+
+ // Build the half-module
+
+ // id is hard coded
+ int component_number = 3;
+
+ Hybrid hybrid = new Hybrid(volName,mother,component_number);
+ hybrid.setMaterial("G10");
+
+ TestRunHalfModuleBundle hm = (TestRunHalfModuleBundle) getHalfModuleBundle((BaseModule) mother.getMother(), mother.getName());
+ hm.hybrid = hybrid;
+
+ if(isDebug()) System.out.printf("%s: added hybrid to half-module with name %s \n", this.getClass().getSimpleName(), hm.halfModule.getName());
+
+
+ }
+
+ void makeHalfModuleComponentCF(TestRunHalfModule mother) {
+
+ if(isDebug()) System.out.printf("%s: makeHalfModuleComponentCF for %s \n", this.getClass().getSimpleName(), mother.getName());
+
+
+ String volName = mother.getName() + "_cf";
+
+ // Build the half-module
+
+ // id is hard coded
+ int component_number = 1;
+
+ CarbonFiber cf = new CarbonFiber(volName,mother,component_number);
+ cf.setMaterial("CarbonFiber");
+
+ TestRunHalfModuleBundle hm = (TestRunHalfModuleBundle) getHalfModuleBundle((BaseModule) mother.getMother(), mother.getName());
+ hm.carbonFiber = cf;
+
+ }
+
+ void makeHalfModuleComponentKapton(BaseModule mother) {
+
+ if(isDebug()) System.out.printf("%s: makeHalfModuleComponentKapton for %s \n", this.getClass().getSimpleName(), mother.getName());
+
+ String volName = mother.getName() + "_lamination";
+
+ // Build the half-module
+
+ // id is hard coded
+ int component_number = 2;
+
+ HalfModuleLamination lamination = new HalfModuleLamination(volName,mother,component_number);
+ lamination.setMaterial("Kapton");
+
+
+ HalfModuleBundle hm = getHalfModuleBundle((BaseModule) mother.getMother(), mother.getName());
+ hm.lamination = lamination;
+
+ }
+
+
+
+ protected void makeHalfModuleComponentSensor(BaseModule mother) {
+
+ if(isDebug()) System.out.printf("%s: makeHalfModuleComponentSensor for %s \n", this.getClass().getSimpleName(), mother.getName());
+
+ String volName = mother.getName() + "_sensor";
+
+ // sensor id is hard coded in old geometry to be zero by counting over the components of the module
+ int component_number = 0;
+
+ //
+ Sensor sensor = new Sensor(volName, mother, null, component_number);
+ sensor.setMaterial("Silicon");
+
+ HalfModuleBundle hm = getHalfModuleBundle((BaseModule)mother.getMother(), mother.getName());
+ hm.sensor = sensor;
+
+
+ makeHalfModuleComponentActiveSensor(sensor);
+
+
+ }
+
+ private void makeHalfModuleComponentActiveSensor(Sensor mother) {
+
+ if(isDebug()) System.out.printf("%s: makeHalfModuleComponentActiveSensor for %s \n", this.getClass().getSimpleName(), mother.getName());
+
+ String volName = mother.getName() + "_active";
+
+ ActiveSensor active_sensor = new ActiveSensor(volName, mother);
+ active_sensor.setMaterial("Silicon");
+
+ HalfModuleBundle hm = getHalfModuleBundle((BaseModule) mother.getMother().getMother(), mother.getMother().getName());
+ hm.activeSensor = active_sensor;
+
+ }
+
+
+
+
+ /**
+ * Tracking volume geometry definition.
+ */
+ public static class TrackingVolume extends SurveyVolume {
+ public TrackingVolume(String name, SurveyVolume mother) {
+ super(name,mother, null);
+ init();
+ }
+ protected void setPos() {
+ // Dummy survey positions to setup a coordinate system
+ ballPos = new BasicHep3Vector(0,0,0);
+ veePos = new BasicHep3Vector(1,0,0);
+ flatPos = new BasicHep3Vector(0,1,0);
+ }
+ protected void setCenter() {
+ // at the origin
+ setCenter(new BasicHep3Vector(0,0,0));
+ }
+ protected void setBoxDim() {
+ // do nothing since we are not building a tracking volume
+ }
+ }
+
+ /**
+ * TODO This class is shared among geometry definitions but should really be in the test run class. Fix this.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+ public static class TestRunModuleBundle extends BaseModuleBundle {
+ public HalfModuleBundle halfModuleAxial = null;
+ public HalfModuleBundle halfModuleStereo = null;
+ protected SurveyVolume coldBlock = null;
+ public TestRunModuleBundle(BaseModule m) {
+ super(m);
+ }
+ public void print() {
+ if(module!=null) System.out.printf("%s: %s\n", this.getClass().getSimpleName(),module.toString());
+ if(halfModuleAxial!=null) halfModuleAxial.print();
+ if(coldBlock!=null)System.out.printf("%s: %s\n", this.getClass().getSimpleName(),coldBlock.getName());
+ if(halfModuleStereo!=null) halfModuleStereo.print();
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerJavaBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerJavaBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerJavaBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,172 @@
+package org.lcsim.geometry.compact.converter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jdom.Element;
+import org.lcsim.detector.DetectorIdentifierHelper;
+import org.lcsim.detector.IDetectorElement;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.detector.identifier.ExpandedIdentifier;
+import org.lcsim.detector.identifier.IExpandedIdentifier;
+import org.lcsim.detector.identifier.IIdentifierDictionary;
+import org.lcsim.detector.tracker.silicon.SiTrackerModule;
+import org.lcsim.geometry.compact.Subdetector;
+
+public abstract class HPSTrackerJavaBuilder implements IHPSTrackerJavaBuilder {
+
+ protected boolean _debug = false;
+ private JavaSurveyVolume baseSurveyVolume;
+ protected List<JavaSurveyVolume> javaSurveyVolumes = new ArrayList<JavaSurveyVolume>();
+ protected DetectorIdentifierHelper detectorIdentifierHelper;
+ protected IIdentifierDictionary identifierDictionary;
+ protected Subdetector subdet;
+ protected List<IDetectorElement> layerDetectorElements = new ArrayList<IDetectorElement>();
+ protected List<IDetectorElement> moduleDetectorElements = new ArrayList<IDetectorElement>();
+ protected IDetectorElement baseDetectorElement = null;
+ public HPSTrackerBuilder _builder = null;
+ protected Element node = null;
+
+ public HPSTrackerJavaBuilder(boolean debugFlag, Element node) {
+ this._debug=debugFlag;
+ this.node = node;
+ }
+
+ public abstract void build(ILogicalVolume trackingVolume);
+ public abstract HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug, Element node);
+
+
+ /**
+ * Add to list of objects.
+ * @param geom - object to add.
+ */
+ public void add(JavaSurveyVolume geom) {
+ javaSurveyVolumes.add(geom);
+ }
+
+ public void setBuilder(HPSTrackerBuilder b) {
+ _builder = b;
+ }
+
+ public void build() {
+ _builder.build();
+ }
+
+ public void setDebug(boolean debug) {
+ _debug = debug;
+ }
+
+ public boolean isDebug() {
+ return _debug;
+ }
+
+
+ public DetectorIdentifierHelper getDetectorIdentifierHelper() {
+ return detectorIdentifierHelper;
+ }
+
+ public void setDetectorIdentifierHelper(
+ DetectorIdentifierHelper detectorIdentifierHelper) {
+ this.detectorIdentifierHelper = detectorIdentifierHelper;
+ }
+
+ public IIdentifierDictionary getIdentifierDictionary() {
+ return identifierDictionary;
+ }
+
+ public void setIdentifierDictionary(
+ IIdentifierDictionary identifierDictionary) {
+ this.identifierDictionary = identifierDictionary;
+ }
+
+
+ public void setSubdetector(Subdetector subdet) {
+ this.subdet = subdet;
+ }
+
+ public Subdetector getSubdetector() {
+ return this.subdet;
+ }
+
+
+
+
+
+ // This finds specific type. I would like to use the ID for this but can't, I think.
+ // TODO there must be a factory instance to do this
+ public SiTrackerModule getModuleDetectorElement(SiTrackerModule testElement) {
+ if(isDebug()) System.out.printf("%s: getModuleDetectorElement for module %s path: \"%s\"\n", this.getClass().getSimpleName(),testElement.getName(),testElement.getGeometry().getPathString());
+ SiTrackerModule element = null;
+ for(IDetectorElement e : moduleDetectorElements) {
+ SiTrackerModule m = (SiTrackerModule) e;
+ if(isDebug()) System.out.printf("%s: compare with module %s path: %s\"%s\" \n", this.getClass().getSimpleName(),m.getName(),m.getGeometry().getPathString());
+ if(m.getGeometry().getPathString().equals(testElement.getGeometry().getPathString())) {
+ if(element!=null) throw new RuntimeException("two DE sharing extended ID?");
+ if(isDebug()) System.out.printf("%s: found it\n", this.getClass().getSimpleName());
+ element = m;
+ }
+ }
+ return element;
+ }
+
+
+ // Find detector elements
+ // TODO This should be using some global geometry code like DetectorElementStore?
+ public IDetectorElement getLayerDetectorElement(IExpandedIdentifier expId) {
+ IDetectorElement element = null;
+ if(isDebug()) System.out.printf("%s: search among %d layer DEs\n", this.getClass().getSimpleName(), layerDetectorElements.size());
+ for(IDetectorElement e : layerDetectorElements) {
+ if(isDebug()) System.out.printf("%s: test %s\n", this.getClass().getSimpleName(),e.getName());
+ ExpandedIdentifier eId = (ExpandedIdentifier) e.getExpandedIdentifier();
+ if(eId.equals(expId)) { // TODO order matters as expId is an interface without that function!?
+ //check that only one was found
+ if(element!=null) throw new RuntimeException("two DE sharing extended ID?");
+ if(isDebug()) System.out.printf("%s: found it\n", this.getClass().getSimpleName());
+ element = e;
+ }
+
+ }
+ return element;
+ }
+
+
+ public void addLayerDetectorElement(IDetectorElement e) {
+ IExpandedIdentifier expId = e.getExpandedIdentifier();
+ if(getLayerDetectorElement(expId) != null)
+ throw new RuntimeException("Trying to add an existing layer detector element.");
+ layerDetectorElements.add(e);
+ }
+
+ public void addBaseDetectorElement(IDetectorElement e) {
+ baseDetectorElement = e;
+ }
+
+ public IDetectorElement getBaseDetectorElement() {
+ return baseDetectorElement;
+ }
+
+ public void addModuleDetectorElement(IDetectorElement e) {
+ if(!(e instanceof SiTrackerModule))
+ throw new RuntimeException("Trying to add an existing module of wrong type.");
+ if(getModuleDetectorElement((SiTrackerModule) e) != null)
+ throw new RuntimeException("Trying to add an already existing module detector element.");
+ layerDetectorElements.add(e);
+ }
+
+
+ /**
+ * @return the baseTrackerGeometry
+ */
+ public JavaSurveyVolume getBaseTrackerGeometry() {
+ return baseSurveyVolume;
+ }
+
+ /**
+ * @param baseTrackerGeometry the baseTrackerGeometry to set
+ */
+ public void setBaseTrackerGeometry(JavaSurveyVolume baseTrackerGeometry) {
+ this.baseSurveyVolume = baseTrackerGeometry;
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerLCDDBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerLCDDBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/HPSTrackerLCDDBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,129 @@
+package org.lcsim.geometry.compact.converter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jdom.Element;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+
+public abstract class HPSTrackerLCDDBuilder implements IHPSTrackerLCDDBuilder {
+
+ public boolean _debug = true;
+ protected LCDD lcdd = null;
+ protected LCDDSurveyVolume baseSurveyVolume;
+ protected List<LCDDSurveyVolume> lcddSurveyVolumes = new ArrayList<LCDDSurveyVolume>();
+ private SensitiveDetector sensitiveDetector;
+ public HPSTrackerBuilder _builder = null;
+ protected Element node;
+
+
+
+ public HPSTrackerLCDDBuilder(boolean debugFlag, Element node, LCDD lcdd2, SensitiveDetector sens) {
+ setDebug(debugFlag);
+ setLCDD(lcdd2);
+ setSensitiveDetector(sens);
+ setNode(node);
+ }
+
+ /**
+ * Build the LCDD geometry objects.
+ * @param worldVolume - the reference volume.
+ */
+ public abstract void build(Volume worldVolume);
+
+
+ public abstract void setBuilder();
+
+ public abstract HPSTrackerGeometryDefinition createGeometryDefinition(boolean debug, Element node);
+
+
+ public void setNode(Element node) {
+ this.node = node;
+ }
+
+ public void setSensitiveDetector(SensitiveDetector sens) {
+ this.sensitiveDetector = sens;
+ }
+
+ public SensitiveDetector getSensitiveDetector() {
+ return this.sensitiveDetector;
+ }
+
+ public void setBuilder(HPSTrackerBuilder b) {
+ _builder = b;
+ }
+
+ public HPSTrackerBuilder getBuilder() {
+ return _builder;
+ }
+
+ public void build() {
+ _builder.build();
+ }
+
+ public void setDebug(boolean debug) {
+ _debug = debug;
+ }
+
+ public boolean isDebug() {
+ return _debug;
+ }
+
+ /**
+ * Add to list of objects.
+ * @param geom - object to add.
+ */
+ public void add(LCDDSurveyVolume geom) {
+ lcddSurveyVolumes.add(geom);
+ }
+
+
+
+
+ public void setLCDD(LCDD lcdd) {
+ this.lcdd = lcdd;
+ }
+
+ public LCDD getLCDD() {
+ return lcdd;
+ }
+
+ public LCDDSurveyVolume getBaseLCDD() {
+ return baseSurveyVolume;
+ }
+
+ public void setVisualization() {
+
+ if(isDebug()) System.out.printf("%s: Set LCDD visualization for %d LCDD geometry objects \n", getClass().getSimpleName(), lcddSurveyVolumes.size());
+ for(SurveyVolumeImpl g : lcddSurveyVolumes) {
+ String name = g.getName();
+ if(isDebug()) System.out.printf("%s: Set LCDD vis for %s \n", getClass().getSimpleName(), name);
+ if(name.contains("base_plate")) g.setVisName("BasePlateVis");
+ else if(name.equals("base")) g.setVisName("SvtBoxVis");
+ else if(name.contains("chamber")) g.setVisName("ChamberVis");
+ else if(name.contains("support_bottom") || name.contains("support_top")) g.setVisName("SupportVolumeVis");
+ else if(name.contains("support_plate")) g.setVisName("SupportPlateVis");
+ else if(name.startsWith("module_")) {
+ if(name.endsWith("halfmodule_axial") || name.endsWith("halfmodule_stereo")) g.setVisName("HalfModuleVis");
+ else if(name.endsWith("cold")) g.setVisName("ColdBlockVis");
+ else if(name.endsWith("lamination")) g.setVisName("KaptonVis");
+ else if(name.endsWith("sensor")) g.setVisName("SensorVis");
+ else if(name.endsWith("sensor_active")) g.setVisName("SensorVis");
+ else if(name.endsWith("cf")) g.setVisName("CarbonFiberVis");
+ else if(name.endsWith("hybrid")) g.setVisName("HybridVis");
+ else {
+ //this must be a module then?
+ g.setVisName("ModuleVis");
+ }
+ }
+ else {
+ if(isDebug()) System.out.printf("%s: No LCDD vis for %s \n", getClass().getSimpleName(), name);
+ }
+ }
+ if(isDebug()) System.out.printf("%s: DONE Set LCDD vis \n", getClass().getSimpleName());
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerJavaBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerJavaBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerJavaBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,31 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.lcsim.detector.DetectorIdentifierHelper;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.detector.identifier.IIdentifierDictionary;
+import org.lcsim.geometry.compact.Subdetector;
+
+public interface IHPSTrackerJavaBuilder {
+
+ /**
+ * Build the JAVA geometry objects from the geometry definition.
+ * @param trackingVolume - the reference volume.
+ */
+ public void build(ILogicalVolume trackingVolume);
+
+ public DetectorIdentifierHelper getDetectorIdentifierHelper();
+
+ public void setDetectorIdentifierHelper(
+ DetectorIdentifierHelper detectorIdentifierHelper);
+
+ public IIdentifierDictionary getIdentifierDictionary();
+
+ public void setIdentifierDictionary(
+ IIdentifierDictionary identifierDictionary);
+
+
+ public void setSubdetector(Subdetector subdet);
+
+ public Subdetector getSubdetector();
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerLCDDBuilder.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerLCDDBuilder.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/IHPSTrackerLCDDBuilder.java Tue May 5 14:05:24 2015
@@ -0,0 +1,15 @@
+package org.lcsim.geometry.compact.converter;
+
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+
+public interface IHPSTrackerLCDDBuilder {
+
+ public void setSensitiveDetector(SensitiveDetector sens);
+
+ public SensitiveDetector getSensitiveDetector();
+
+ public void build(Volume worldVolume);
+
+ public void setVisualization();
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaGhostSurveyVolume.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaGhostSurveyVolume.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaGhostSurveyVolume.java Tue May 5 14:05:24 2015
@@ -0,0 +1,28 @@
+package org.lcsim.geometry.compact.converter;
+
+/**
+ *
+ * Interface to the JAVA converter geometry for the geometry definition.
+ * In this case no volume is built but can be used as reference in building the geometry.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+public class JavaGhostSurveyVolume extends JavaSurveyVolume {
+
+ /**
+ * Initialize with base and mother. This is typically for a reference geometry object
+ * that is used for referencing coordinate systems but that doesn't have a volume itself.
+ * @param surveyVolume - object used to get geometry definitions
+ * @param mother - mother object
+ */
+ public JavaGhostSurveyVolume(SurveyVolume surveyVolume, JavaSurveyVolume mother) {
+ super(surveyVolume);
+ if(isDebug()) System.out.printf("%s: constructing JAVA ghost object %s with mother %s\n", this.getClass().getSimpleName(),surveyVolume.getName(),mother==null?"null":mother.getName());
+ setMother(mother);
+ mother.addDaughter(this);
+ setPositionAndRotation(surveyVolume);
+ if(isDebug()) System.out.printf("%s: DONE constructing JAVA object %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+ }
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaSurveyVolume.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaSurveyVolume.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/JavaSurveyVolume.java Tue May 5 14:05:24 2015
@@ -0,0 +1,292 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.VecOp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.detector.IPhysicalVolume;
+import org.lcsim.detector.IRotation3D;
+import org.lcsim.detector.ITranslation3D;
+import org.lcsim.detector.LogicalVolume;
+import org.lcsim.detector.PhysicalVolume;
+import org.lcsim.detector.RotationGeant;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.detector.Translation3D;
+import org.lcsim.detector.material.IMaterial;
+import org.lcsim.detector.material.MaterialStore;
+import org.lcsim.detector.solids.Box;
+import org.lcsim.geometry.util.TransformationUtils;
+
+/**
+ * Interface to the JAVA converter geometry for the geometry definition.
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+public class JavaSurveyVolume extends SurveyVolumeImpl {
+ private Box box= null;
+ private ILogicalVolume volume = null;
+ private ITranslation3D pos = null;
+ private IRotation3D rot = null;
+ private IPhysicalVolume physVolume = null;
+ private JavaSurveyVolume mother = null;
+ public List<JavaSurveyVolume> daughters = new ArrayList<JavaSurveyVolume>();
+ private int componentId = -1;
+
+ /**
+ * Default constructor
+ */
+ public JavaSurveyVolume(SurveyVolume surveyVolume) {
+ super(surveyVolume);
+ }
+
+ /**
+ * Construct a JAVA geometry object from its geometry definition and an already built logical volume.
+ * This is typically used by the tracking volume.
+ * @param surveyVolume - input geometry definition
+ * @param vol - logical volume
+ */
+ public JavaSurveyVolume(SurveyVolume surveyVolume, ILogicalVolume vol) {
+ super(surveyVolume);
+ if(isDebug()) System.out.printf("%s: JavaBaseGeometry %s (given logical volume %s)\n", this.getClass().getSimpleName(),surveyVolume.getName(),vol.getName());
+ // this must be tracking volume. May change in the future and is probably weird to make this requirement here.
+ if(!surveyVolume.getName().contains("tracking")) throw new RuntimeException("this constructor is only used with the tracking volume!?");
+ setVolume(vol);
+ // since it's tracking volume, set the pos and rotation trivially
+ Hep3Vector lcdd_rot_angles = TransformationUtils.getCardanAngles(surveyVolume.getCoord().v(), surveyVolume.getCoord().w(), new BasicHep3Vector(0,1,0),new BasicHep3Vector(0,0,1));
+ setPos(new Translation3D(0,0,0));
+ setRot(new RotationGeant(lcdd_rot_angles.x(), lcdd_rot_angles.y(), lcdd_rot_angles.z()));
+ if(isDebug()) System.out.printf("%s: DONE JavaBaseGeometry %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+ }
+
+ /**
+ * Construct a JAVA geometry object from its geometry definition.
+ * @param surveyVolume - input geometry definition
+ * @param mother - reference to mother JAVA definition
+ * @param volumeId - component id number
+ */
+ public JavaSurveyVolume(SurveyVolume surveyVolume, JavaSurveyVolume mother, int volumeId) {
+ super(surveyVolume);
+ if(isDebug()) System.out.printf("%s: JavaBaseGeometry %s (volumeID %d, mother %s)\n", this.getClass().getSimpleName(),surveyVolume.getName(),volumeId,mother==null?"null":mother.getName());
+ setComponentId(volumeId);
+ setMother(mother);
+ mother.addDaughter(this);
+ buildBox();
+ buildVolume();
+ setPositionAndRotation(surveyVolume);
+ if(isDebug()) System.out.printf("%s: DONE JavaBaseGeometry %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+ }
+
+ protected boolean hasCoordinateSystemInfo() {
+ return pos!=null && rot!=null;
+ }
+
+
+ public void buildPhysVolume() {
+ if(isDebug()) System.out.printf("%s: build phys volume for %s with mother %s and physical mother %s\n", this.getClass().getSimpleName(),getName(),getMother().getName(),getPhysMother().getName());
+ JavaSurveyVolume physMother = getPhysMother();
+ setPhysVolume(new PhysicalVolume(new Transform3D(getPos(), getRot()), getName(), volume, physMother.getVolume(),getComponentId()));
+ }
+
+ public void buildBox() {
+ Hep3Vector b = VecOp.mult(0.5,getBoxDim());
+ if(isDebug()) System.out.printf("%s: build box for %s with dimensions %s \n", this.getClass().getSimpleName(),getName(), b);
+ setBox(new Box(getName() + "Box", b.x(), b.y(), b.z()));
+ }
+ public void buildVolume() {
+ if(isDebug()) System.out.printf("%s: build volume for %s with material %s\n", this.getClass().getSimpleName(),getName(), MaterialStore.getInstance().get(getMaterial()));
+ setVolume(new LogicalVolume(getName() + "_volume", box, MaterialStore.getInstance().get(getMaterial())));
+
+ }
+ public void setPositionAndRotation(SurveyVolume base) {
+ if(isDebug()) System.out.printf("%s: set position and rotation for volume %s\n", this.getClass().getSimpleName(),getName());
+
+ // no mother, this must be the world/tracking volume!?
+ if(base.getMother()==null) throw new RuntimeException("trying to set coordinates w/o mother defined for "+base.getName());
+
+ // Vector from origin to center of box locally
+ Hep3Vector box_center_base_local = base.getCenter();
+
+ // find the physical mother i.e. not a ghost volume and compound transformations to it
+ JavaSurveyVolume physMother = getPhysMother();
+ if(isDebug()) System.out.printf("%s: physical mother to transform to is %s; find the transform to it\n", this.getClass().getSimpleName(),physMother.getName());
+ Transform3D trf = HPSTrackerBuilder.getTransform(base.getCoord().getTransformation(),base.getMother(),physMother.getName());
+ if(isDebug()) System.out.printf("%s: found transform to physical mother \n%s\n\n", this.getClass().getSimpleName(),trf.toString());
+
+ // find the position of the center in the physical mother coord
+ Hep3Vector box_center_base = trf.transformed(box_center_base_local);
+
+ // find the position of the center of the box in the mother coordinate system, make sure to use the physical mother coordinates
+ if(isDebug()) System.out.printf("%s: find center of box in physical mother coord %s \n", this.getClass().getSimpleName(),physMother.getName());
+ // hack since my getTransform function needs a mother TODO Fix this!
+ SurveyVolume gm = base;
+ if(isDebug()) System.out.printf("%s: look for physical mother %s starting from mother %s \n", this.getClass().getSimpleName(),physMother.getName(),gm.getMother()!=null?gm.getMother().getName():"-- no mother --");
+ while((gm=gm.getMother()).getName()!=physMother.getName()) {
+ if(isDebug()) System.out.printf("%s: gm is %s \n", this.getClass().getSimpleName(),gm.getName());
+ //gm = gm.getMother();
+ }
+ if(isDebug()) System.out.printf("%s: found physical mother %s with center at %s \n", this.getClass().getSimpleName(),gm.getName(), gm.getCenter());
+
+ Hep3Vector mother_center = gm.getCenter();
+
+ // now calculate the position of this box center in the mother LCDD coordinates
+ Hep3Vector box_center = VecOp.sub(box_center_base, mother_center);
+
+ //Find LCDD Euler rotation angles from coordinate system unit vectors
+ //Note that this has to be rotation wrt to physical mother and not just mother as normally is the case
+ //Use apache lib to get angles, but in principle I should already have it from the trf above
+ //Hep3Vector lcdd_rot_angles = HPSTestRunTracker2014.getEulerAngles(base.getCoord().v(), base.getCoord().w(), new BasicHep3Vector(0,1,0),new BasicHep3Vector(0,0,1));
+ if(isDebug()) System.out.printf("%s: find LCDD Cardan rotation angles - need to find mother to physical mother transform \n", this.getClass().getSimpleName(),physMother.getName());
+ Hep3Vector base_u = base.getCoord().u();
+ Hep3Vector base_v = base.getCoord().v();
+ Hep3Vector base_w = base.getCoord().w();
+ if(isDebug()) System.out.printf("%s: unit vectors in mother coord: %s, %s, %s\n", this.getClass().getSimpleName(),base_u.toString(),base_v.toString(),base_w.toString());
+ Hep3Vector unit_u = new BasicHep3Vector(1,0,0);
+ Hep3Vector unit_v = new BasicHep3Vector(0,1,0);
+ Hep3Vector unit_w = new BasicHep3Vector(0,0,1);
+ if(!base.getMother().getName().equals(physMother.getName())) {
+ if(isDebug()) System.out.printf("%s: Need to get unit vectors in physical mother %s coord system\n", this.getClass().getSimpleName(),physMother.getName());
+ Transform3D trf_mother = HPSTrackerBuilder.getTransform(base.getMother().getCoord().getTransformation(),base.getMother().getMother(),physMother.getName());
+ if(isDebug()) System.out.printf("%s: found transform from mother to physical mother \n%s\n", this.getClass().getSimpleName(),trf_mother.toString());
+ //unit_u = VecOp.unit(trf_mother.rotated(unit_u));
+ //unit_v = VecOp.unit(trf_mother.rotated(unit_v));
+ //unit_w = VecOp.unit(trf_mother.rotated(unit_w));
+ base_u = VecOp.unit(trf_mother.rotated(base_u));
+ base_v = VecOp.unit(trf_mother.rotated(base_v));
+ base_w = VecOp.unit(trf_mother.rotated(base_w));
+
+ } else {
+ if(isDebug()) System.out.printf("%s: mother and physical mother is the same so unit vectors didn't change\n",getClass().getSimpleName());
+ }
+
+ if(isDebug()) {
+ if(isDebug()) System.out.printf("%s: final unit vectors to get Cardan angles from : \n%s, %s, %s -> %s, %s, %s \n",
+ this.getClass().getSimpleName(),
+ base_u.toString(),base_v.toString(),base_w.toString(),
+ unit_u.toString(),unit_v.toString(),unit_w.toString());
+ //System.out.printf("%s: unit vectors u %s v %s w %s\n", this.getClass().getSimpleName(),base.getCoord().u().toString(),base.getCoord().v().toString(),base.getCoord().w().toString());
+ }
+
+ Hep3Vector lcdd_rot_angles = TransformationUtils.getCardanAngles(base_u, base_v, base_w, unit_u, unit_v, unit_w);
+
+
+ // Create the LCDD position
+ setPos(new Translation3D(box_center.x(), box_center.y(), box_center.z()));
+ setRot(new RotationGeant(lcdd_rot_angles.x(), lcdd_rot_angles.y(), lcdd_rot_angles.z()));
+
+ if(isDebug()) {
+
+ System.out.printf("%s: SurveyVolume information for %s:\n", this.getClass().getSimpleName(), base.getName());
+ System.out.printf("%s: box_center_base_local %s\n", this.getClass().getSimpleName(), box_center_base_local.toString());
+ System.out.printf("%s: box_center_base %s\n", this.getClass().getSimpleName(), box_center_base.toString());
+ System.out.printf("%s: mother center %s\n", this.getClass().getSimpleName(), base.getMother()==null?" <no mother> ":mother_center.toString());
+ System.out.printf("%s: box_center %s\n", this.getClass().getSimpleName(), box_center.toString());
+ System.out.printf("%s: pos %s\n", this.getClass().getSimpleName(), getPos().toString());
+ Hep3Vector box_center_tracking_xcheck = HPSTrackerBuilder.transformToTracking(box_center_base_local, base);
+ System.out.printf("%s: box_center_tracking_xcheck %s (for %s)\n", this.getClass().getSimpleName(), box_center_tracking_xcheck==null ? " <null> " : box_center_tracking_xcheck.toString(),base.getName());
+ Hep3Vector box_center_envelope_xcheck2 = HPSTrackerBuilder.transformToParent(box_center_base_local, base, "base");
+ System.out.printf("%s: box_center_base_xcheck2 %s (for %s)\n", this.getClass().getSimpleName(), box_center_envelope_xcheck2==null ? " <null> " : box_center_envelope_xcheck2.toString(),base.getName());
+ if(box_center_envelope_xcheck2!=null) {
+ Hep3Vector box_center_envelope_xcheck2_inch = VecOp.mult(0.0393701, box_center_envelope_xcheck2);
+ System.out.printf("%s: box_center_base_xcheck2_in %s (for %s)\n", this.getClass().getSimpleName(), box_center_envelope_xcheck2_inch==null ? " <null> " : box_center_envelope_xcheck2_inch.toString(),base.getName());
+ }
+ Hep3Vector origin = base.getCoord().origin();
+ if(origin!=null) {
+ Hep3Vector origin_in = VecOp.mult(0.0393701, origin);
+ System.out.printf("%s: origin_in %s (%s)\n", this.getClass().getSimpleName(), origin_in==null ? " <null> " : origin_in.toString(), base.getName());
+ }
+ Hep3Vector origin_base = HPSTrackerBuilder.transformToParent(base.getCoord().origin(), base, "base");
+ if(origin_base!=null) {
+ Hep3Vector origin_base_in = VecOp.mult(0.0393701, origin_base);
+ System.out.printf("%s: origin_base_in %s\n", this.getClass().getSimpleName(), origin_base_in==null ? " <null> " : origin_base_in.toString());
+ }
+ System.out.printf("%s: euler %s\n", this.getClass().getSimpleName(), lcdd_rot_angles.toString());
+ System.out.printf("%s: rot %s\n", this.getClass().getSimpleName(), getRot().toString());
+
+ }
+
+ }
+
+ /**
+ * Find the first non-ghost volume among parents.
+ * @return mother object
+ */
+ public JavaSurveyVolume getPhysMother() {
+ //if(isDebug()) System.out.printf("%s: finding physical mother to %s\n", this.getClass().getSimpleName(), getName());
+ if(mother==null) throw new RuntimeException("Trying to get phys mother but there is no mother!");
+ if(mother instanceof JavaGhostSurveyVolume) {
+ return mother.getPhysMother();
+ } else {
+ //if(isDebug()) System.out.printf("%s: found a non-ghost volume: %s\n", this.getClass().getSimpleName(), mother.getName());
+ return mother;
+ }
+ }
+
+
+ public ILogicalVolume getVolume() {
+ return volume;
+ }
+ protected void setVolume(ILogicalVolume volume) {
+ this.volume = volume;
+ }
+ protected Box getBox() {
+ return box;
+ }
+ protected void setBox(Box b) {
+ box = b;
+ }
+ protected ITranslation3D getPos() {
+ return pos;
+ }
+ protected void setPos(ITranslation3D iTranslation3D) {
+ this.pos = iTranslation3D;
+ }
+ protected IRotation3D getRot() {
+ return rot;
+ }
+ protected void setRot(IRotation3D iRotation3D) {
+ this.rot = iRotation3D;
+ }
+ public JavaSurveyVolume getMother() {
+ return mother;
+ }
+ protected void setMother(JavaSurveyVolume mother) {
+ this.mother = mother;
+ }
+ public IPhysicalVolume getPhysVolume() {
+ return physVolume;
+ }
+ protected void setPhysVolume(PhysicalVolume physVolume) {
+ this.physVolume = physVolume;
+ }
+
+ public List<JavaSurveyVolume> getDaughters() {
+ return daughters;
+ }
+
+ protected void addDaughter(JavaSurveyVolume o) {
+ getDaughters().add(o);
+ }
+
+ public int getComponentId() {
+ return componentId;
+ }
+
+ public void setComponentId(int componentId) {
+ this.componentId = componentId;
+ }
+
+ public String toString() {
+ String s = "JavaBaseGeometry " + getName() + "\n";
+ if(getPos()!=null && getRot()!=null) {
+ s += "Position: " + getPos().toString() + "\n";
+ s += "Rotation: " + getRot().toString() + "\n";
+ } else {
+ s+= " - no position/rotation info -\n";
+ }
+ return s;
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDGhostSurveyVolume.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDGhostSurveyVolume.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDGhostSurveyVolume.java Tue May 5 14:05:24 2015
@@ -0,0 +1,29 @@
+package org.lcsim.geometry.compact.converter;
+
+/**
+ *
+ * Interface to the LCDD converter geometry for the geometry definition.
+ * No volume is built but it can be used as reference in building the geometry.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ *
+ */
+public class LCDDGhostSurveyVolume extends LCDDSurveyVolume {
+
+
+
+ /**
+ * Initialize with base and mother. This is typically for a reference geometry object
+ * that is used for referencing coordinate systems but that doesn't have a volume itself.
+ * @param base - object used to get geometry definitions
+ * @param mother - mother LCDD object
+ */
+ public LCDDGhostSurveyVolume(SurveyVolume base, LCDDSurveyVolume mother) {
+ super(base);
+ if(isDebug()) System.out.printf("%s: constructing LCDD ghost object %s with mother %s\n", this.getClass().getSimpleName(),base.getName(),mother==null?"null":mother.getName());
+ setMother(mother);
+ mother.addDaughter(this);
+ if(isDebug()) System.out.printf("%s: DONE constructing LCDD object %s\n", this.getClass().getSimpleName(),base.getName());
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDSurveyVolume.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDSurveyVolume.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/LCDDSurveyVolume.java Tue May 5 14:05:24 2015
@@ -0,0 +1,270 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.VecOp;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.jdom.JDOMException;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.geometry.compact.converter.lcdd.util.Box;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.Material;
+import org.lcsim.geometry.compact.converter.lcdd.util.PhysVol;
+import org.lcsim.geometry.compact.converter.lcdd.util.Position;
+import org.lcsim.geometry.compact.converter.lcdd.util.Rotation;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+import org.lcsim.geometry.util.TransformationUtils;
+
+/**
+ * Interface to the LCDD converter geometry for the geometry definition.
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+public class LCDDSurveyVolume extends SurveyVolumeImpl {
+ Box box= null;
+ Volume volume = null;
+ private Position pos = null;
+ private Rotation rot = null;
+ private PhysVol physVolume = null;
+ LCDD lcdd = null;
+ private LCDDSurveyVolume mother = null;
+ protected Map<String,Integer> physVolId = null;
+ public List<LCDDSurveyVolume> daughters = new ArrayList<LCDDSurveyVolume>();
+ /**
+ * Default constructor
+ * @param surveyVolume - core geometry definitions
+ */
+ public LCDDSurveyVolume(SurveyVolume surveyVolume) {
+ super(surveyVolume);
+ }
+
+ /**
+ * Initialize this object with a known volume and no mother. Typically the world volume would use this.
+ * @param surveyVolume - core geometry definitions
+ * @param vol - given volume
+ */
+ public LCDDSurveyVolume(SurveyVolume surveyVolume, Volume volume) {
+ super(surveyVolume);
+ if(isDebug()) System.out.printf("%s: constructing LCDD object %s with volume name %s\n", this.getClass().getSimpleName(),surveyVolume.getName(),volume.getName());
+ setVolume(volume);
+ if(isDebug()) System.out.printf("%s: DONE constructing LCDD object %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+ Hep3Vector lcdd_rot_angles = TransformationUtils.getCardanAngles(surveyVolume.getCoord().v(), surveyVolume.getCoord().w(), new BasicHep3Vector(0,1,0),new BasicHep3Vector(0,0,1));
+ setPos(new Position(getName() + "_position", 0, 0, 0));
+ setRot(new Rotation(getName() + "_rotation",lcdd_rot_angles.x(), lcdd_rot_angles.y(), lcdd_rot_angles.z()));
+ if(isDebug()) System.out.printf("%s: DONE %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+ }
+
+ /**
+ * Interface to the LCDD converter geometry for the geometry definition.
+ * @param surveyVolume - core geometry definition
+ * @param lcdd - lcdd file
+ * @param mother - reference to mother LCDD definition
+ */
+ public LCDDSurveyVolume(SurveyVolume surveyVolume, LCDD lcdd, LCDDSurveyVolume mother) {
+ super(surveyVolume);
+ if(isDebug()) System.out.printf("%s: constructing LCDD object %s with mother %s\n", this.getClass().getSimpleName(),surveyVolume.getName(),mother==null?"null":mother.getName());
+ this.lcdd = lcdd;
+ setMother(mother);
+ mother.addDaughter(this);
+ buildBox();
+ buildVolume();
+ setPositionAndRotation(surveyVolume);
+ //buildPhysVolume(mother);
+ if(isDebug()) System.out.printf("%s: DONE constructing LCDD object %s\n", this.getClass().getSimpleName(),surveyVolume.getName());
+ }
+
+
+ public void buildPhysVolume() {
+
+ if(isDebug()) System.out.printf("%s: build phys volume for %s with mother %s and physical mother %s\n", this.getClass().getSimpleName(),getName(),getMother().getName(),getPhysMother().getName());
+ LCDDSurveyVolume physMother = getPhysMother();
+ setPhysVolume(new PhysVol(volume, physMother.getVolume(), getPos(), getRot()));
+ //if(isDebug()) System.out.printf("%s: build phys volume for %s\n", this.getClass().getSimpleName(),getName());
+ //setPhysVolume(new PhysVol(volume, getMother().getVolume(), getPos(), getRot()));
+ }
+ public void buildBox() {
+ if(isDebug()) System.out.printf("%s: build box for %s\n", getClass().getSimpleName(),getName());
+ setBox(new Box(getName() + "Box", getBoxDim().x(), getBoxDim().y(), getBoxDim().z()));
+ }
+ public void buildVolume() {
+ if(isDebug()) System.out.printf("%s: build volume for %s with material %s\n", this.getClass().getSimpleName(),getName(),getMaterial());
+ try {
+ Material mat = lcdd.getMaterial(getMaterial());
+ setVolume(new Volume(getName() + "_volume", box, mat));
+ } catch (JDOMException e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ public void setPositionAndRotation(SurveyVolume base) {
+ if(isDebug()) System.out.printf("%s: set position and rotation for volume %s\n", this.getClass().getSimpleName(),getName());
+
+ // NOTE:
+ // This sets position and reference w.r.t. mother coordinate system.
+ // If I'm not building that volume this will be wrong.
+ // TODO Similar to in the JAVA converter this should be something like the physical mother.
+
+ if(base.getMother()==null) throw new RuntimeException("trying to set coordinates w/o mother defined for "+base.getName());
+
+ // Vector from origin to center of box locally
+ Hep3Vector box_center_base_local = base.getCenter();
+
+ //translate to the mother coordinate system
+ LCDDSurveyVolume physMother = getPhysMother();
+ if(isDebug()) System.out.printf("%s: physical mother to transform to is %s; find the transform to it\n", this.getClass().getSimpleName(),physMother.getName());
+ Transform3D trf = HPSTrackerBuilder.getTransform(base.getCoord().getTransformation(),base.getMother(),physMother.getName());
+ if(isDebug()) System.out.printf("%s: found transform to physical mother \n%s\n\n", this.getClass().getSimpleName(),trf.toString());
+
+ // find the position of the center in the physical mother coord
+ Hep3Vector box_center_base = trf.transformed(box_center_base_local);
+
+ // find the position of the center of the box in the mother coordinate system, make sure to use the physical mother coordinates
+ if(isDebug()) System.out.printf("%s: find center of box in physical mother coord %s \n", this.getClass().getSimpleName(),physMother.getName());
+ // hack since my getTransform function needs a mother TODO Fix this!
+ SurveyVolume gm = base;
+ if(isDebug()) System.out.printf("%s: look for physical mother %s starting from mother %s \n", this.getClass().getSimpleName(),physMother.getName(),gm.getMother()!=null?gm.getMother().getName():"-- no mother --");
+ while((gm=gm.getMother()).getName()!=physMother.getName()) {
+ if(isDebug()) System.out.printf("%s: gm is %s \n", this.getClass().getSimpleName(),gm.getName());
+ //gm = gm.getMother();
+ }
+ if(isDebug()) System.out.printf("%s: found physical mother %s with center at %s \n", this.getClass().getSimpleName(),gm.getName(), gm.getCenter());
+
+ Hep3Vector mother_center = gm.getCenter();
+
+ // find the position of the center in the mother coord
+ Hep3Vector box_center = VecOp.sub(box_center_base, mother_center);
+
+ //Find LCDD Euler rotation angles from coordinate system unit vectors
+ //Note that this has to be rotation wrt to physical mother and not just mother as normally is the case
+ if(isDebug()) System.out.printf("%s: find LCDD Cardan rotation angles - need to find mother to physical mother transform \n", this.getClass().getSimpleName(),physMother.getName());
+ Hep3Vector base_u = base.getCoord().u();
+ Hep3Vector base_v = base.getCoord().v();
+ Hep3Vector base_w = base.getCoord().w();
+ if(isDebug()) System.out.printf("%s: unit vectors in mother coord: %s, %s, %s\n", this.getClass().getSimpleName(),base_u.toString(),base_v.toString(),base_w.toString());
+ Hep3Vector unit_u = new BasicHep3Vector(1,0,0);
+ Hep3Vector unit_v = new BasicHep3Vector(0,1,0);
+ Hep3Vector unit_w = new BasicHep3Vector(0,0,1);
+ if(!base.getMother().getName().equals(physMother.getName())) {
+ if(isDebug()) System.out.printf("%s: Need to get unit vectors in physical mother %s coord system\n", this.getClass().getSimpleName(),physMother.getName());
+ Transform3D trf_mother = HPSTrackerBuilder.getTransform(base.getMother().getCoord().getTransformation(),base.getMother().getMother(),physMother.getName());
+ if(isDebug()) System.out.printf("%s: found transform from mother to physical mother \n%s\n", this.getClass().getSimpleName(),trf_mother.toString());
+ //unit_u = VecOp.unit(trf_mother.rotated(unit_u));
+ //unit_v = VecOp.unit(trf_mother.rotated(unit_v));
+ //unit_w = VecOp.unit(trf_mother.rotated(unit_w));
+ base_u = VecOp.unit(trf_mother.rotated(base_u));
+ base_v = VecOp.unit(trf_mother.rotated(base_v));
+ base_w = VecOp.unit(trf_mother.rotated(base_w));
+
+ } else {
+ if(isDebug()) System.out.printf("%s: mother and physical mother is the same so unit vectors didn't change\n",getClass().getSimpleName());
+ }
+
+ if(isDebug()) {
+ if(isDebug()) System.out.printf("%s: final unit vectors to get Cardan angles from : \n%s, %s, %s -> %s, %s, %s \n",
+ this.getClass().getSimpleName(),
+ base_u.toString(),base_v.toString(),base_w.toString(),
+ unit_u.toString(),unit_v.toString(),unit_w.toString());
+ //System.out.printf("%s: unit vectors u %s v %s w %s\n", this.getClass().getSimpleName(),base.getCoord().u().toString(),base.getCoord().v().toString(),base.getCoord().w().toString());
+ }
+ Hep3Vector lcdd_rot_angles = TransformationUtils.getCardanAngles(base_u, base_v, base_w, unit_u, unit_v, unit_w);
+
+
+ // Create the LCDD position and rotation
+ setPos(new Position(getName() + "_position",box_center.x(), box_center.y(), box_center.z()));
+ setRot(new Rotation(getName() + "_rotation",lcdd_rot_angles.x(), lcdd_rot_angles.y(), lcdd_rot_angles.z()));
+
+ if(isDebug()) {
+ System.out.printf("%s: SurveyVolume information for %s:\n", this.getClass().getSimpleName(), base.getName());
+ System.out.printf("%s: box_center_base_local %s\n", this.getClass().getSimpleName(), box_center_base_local.toString());
+ System.out.printf("%s: box_center_base %s\n", this.getClass().getSimpleName(), box_center_base.toString());
+ System.out.printf("%s: mother center %s\n", this.getClass().getSimpleName(), mother_center.toString());
+ System.out.printf("%s: box_center %s\n", this.getClass().getSimpleName(), box_center.toString());
+ System.out.printf("%s: pos %s\n", this.getClass().getSimpleName(), getPos().toString());
+ System.out.printf("%s: euler %s\n", this.getClass().getSimpleName(), lcdd_rot_angles.toString());
+ System.out.printf("%s: rot %s\n", this.getClass().getSimpleName(), getRot().toString());
+
+ //calculate the position in tracking volume separately as a xcheck
+ Hep3Vector box_center_tracking_xcheck = HPSTrackerBuilder.transformToTracking(box_center_base_local, base);
+ System.out.printf("%s: box_center_tracking_xcheck %s (for %s)\n", this.getClass().getSimpleName(), box_center_tracking_xcheck.toString(), base.getName());
+ }
+
+ }
+ /**
+ * Find the first non-ghost volume among parents.
+ * @return mother object
+ */
+ public LCDDSurveyVolume getPhysMother() {
+ //if(isDebug()) System.out.printf("%s: finding physical mother to %s\n", this.getClass().getSimpleName(), getName());
+ if(mother==null) throw new RuntimeException("Trying to get phys mother but there is no mother!");
+ if(mother instanceof LCDDGhostSurveyVolume) {
+ return mother.getPhysMother();
+ } else {
+ //if(isDebug()) System.out.printf("%s: found a non-ghost volume: %s\n", this.getClass().getSimpleName(), mother.getName());
+ return mother;
+ }
+ }
+
+ public Volume getVolume() {
+ return volume;
+ }
+ public void setVolume(Volume volume) {
+ this.volume = volume;
+ }
+ public Box getBox() {
+ return box;
+ }
+ public void setBox(Box b) {
+ box = b;
+ }
+ public Position getPos() {
+ return pos;
+ }
+ public void setPos(Position pos) {
+ this.pos = pos;
+ }
+ public Rotation getRot() {
+ return rot;
+ }
+ public void setRot(Rotation rot) {
+ this.rot = rot;
+ }
+ public LCDDSurveyVolume getMother() {
+ return mother;
+ }
+ public void setMother(LCDDSurveyVolume mother) {
+ this.mother = mother;
+ }
+ public PhysVol getPhysVolume() {
+ return physVolume;
+ }
+ public void setPhysVolume(PhysVol physVolume) {
+ this.physVolume = physVolume;
+ }
+ public List<LCDDSurveyVolume> getDaughters() {
+ return daughters;
+ }
+ public void addDaughter(LCDDSurveyVolume o) {
+ getDaughters().add(o);
+ }
+ public String toString() {
+ String s = getClass().getSimpleName() +": " + getName() + "\n";
+ if(getPos()!=null && getRot()!=null) {
+ double x = Double.valueOf(getPos().getAttributeValue("x"));
+ double y = Double.valueOf(getPos().getAttributeValue("y"));
+ double z = Double.valueOf(getPos().getAttributeValue("z"));
+ s += "Position: " + String.format("(%.4f %.4f %.4f)\n", x,y,z);
+ x = Double.valueOf(getRot().getAttributeValue("x"));
+ y = Double.valueOf(getRot().getAttributeValue("y"));
+ z = Double.valueOf(getRot().getAttributeValue("z"));
+ s += "Rotation: " + String.format("(%.4f %.4f %.4f)\n", x,y,z);
+ } else {
+ s += " - no position/rotation info -\n";
+ }
+ return s;
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/MilleParameter.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/MilleParameter.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/MilleParameter.java Tue May 5 14:05:24 2015
@@ -0,0 +1,115 @@
+package org.lcsim.geometry.compact.converter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+
+
+
+public class MilleParameter {
+ private static double corrScaleFactor = -1.;
+ private int id;
+ private double value;
+ private double presigma;
+ private static final Map<Integer,String> dMap;
+ private static final Map<Integer,String> tMap;
+ private static final Map<Integer,String> hMap;
+ static {
+ dMap = new HashMap<Integer,String>();
+ dMap.put(1, "x");dMap.put(2, "y"); dMap.put(3, "z");
+ tMap = new HashMap<Integer,String>();
+ tMap.put(1, "");tMap.put(2, "r");
+ hMap = new HashMap<Integer,String>();
+ hMap.put(1, "t");hMap.put(2, "b");
+ }
+ public static final int half_offset = 10000;
+ public static final int type_offset = 1000;
+ public static final int dimension_offset = 100;
+
+ public MilleParameter(String line) {
+ String[] vals = StringUtils.split(line);// line.split("\\s+");
+ if(vals.length <3) {
+ System.out.println("this line is ill-formatted (" + vals.length + ")");
+ System.out.println(line);
+ System.exit(1);
+ }
+ try {
+ //for(String v : vals) System.out.println("\"" + v + "\"");
+ setId(Integer.parseInt(vals[0]));
+ setValue( corrScaleFactor * Double.parseDouble(vals[1]) );
+ setPresigma(Double.parseDouble(vals[2]));
+
+ } catch (NumberFormatException e) {
+ System.out.println(vals[0] + " " + vals[1] + " " + vals[2]);
+ throw new RuntimeException("problem parsing string ", e);
+ }
+ }
+
+ public MilleParameter(int id, double value, double presigma) {
+ setId(id);
+ setValue(value);
+ setPresigma(presigma);
+ }
+
+ public String getXMLName() {
+ String d = dMap.get(getDim());
+ String t = tMap.get(getType());
+ String h = hMap.get(getHalf());
+ int s = getSensor();
+ return String.format("%s%s%d%s_align", t,d,s,h);
+
+ }
+
+ public int getDim() {
+ int h = (int) (getHalf() * half_offset);
+ int t = (int) (getType() * type_offset);
+ return (int) Math.floor((id- h -t)/(double)dimension_offset);
+ }
+
+ public int getSensor() {
+ int h = (int) (getHalf() * half_offset);
+ int t = (int) (getType() * type_offset);
+ int d = (int) (getDim() * dimension_offset);
+ return (id - h - t -d);
+ }
+
+ public int getType() {
+ int h = (int) (getHalf() * half_offset);
+ return (int) Math.floor((id -h)/(double)type_offset);
+ }
+
+ public int getHalf() {
+ return (int)Math.floor(id/(double)half_offset);
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public double getValue() {
+ return value;
+ }
+
+ public void setValue(double value) {
+ this.value = value;
+ }
+
+ public double getPresigma() {
+ return presigma;
+ }
+
+ public void setPresigma(double presigma) {
+ this.presigma = presigma;
+ }
+
+ public String toString() {
+ return String.format("Milleparameter id=%d half=%d type=%d dim=%d sensor=%d value=%f", this.getId(), this.getHalf(), this.getType(), this.getDim(), this.getSensor(), this.getValue());
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleComponentParameters.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleComponentParameters.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleComponentParameters.java Tue May 5 14:05:24 2015
@@ -0,0 +1,45 @@
+package org.lcsim.geometry.compact.converter;
+
+// TODO: Move to different package.
+public class SiTrackerModuleComponentParameters
+{
+ String materialName;
+ double thickness;
+ boolean sensitive;
+ int componentNumber;
+ String vis;
+
+ public SiTrackerModuleComponentParameters(double thickness, String materialName, int componentNumber, boolean sensitive, String vis)
+ {
+ this.thickness = thickness;
+ this.materialName = materialName;
+ this.sensitive = sensitive;
+ this.componentNumber = componentNumber;
+ this.vis = vis;
+ }
+
+ public double getThickness()
+ {
+ return thickness;
+ }
+
+ public String getMaterialName()
+ {
+ return materialName;
+ }
+
+ public boolean isSensitive()
+ {
+ return sensitive;
+ }
+
+ public int getComponentNumber()
+ {
+ return componentNumber;
+ }
+
+ public String getVis()
+ {
+ return vis;
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleParameters.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleParameters.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SiTrackerModuleParameters.java Tue May 5 14:05:24 2015
@@ -0,0 +1,101 @@
+package org.lcsim.geometry.compact.converter;
+
+import java.util.ArrayList;
+
+import org.jdom.DataConversionException;
+import org.jdom.Element;
+import org.jdom.JDOMException;
+
+// TODO: Move to different package.
+
+public class SiTrackerModuleParameters
+extends ArrayList<SiTrackerModuleComponentParameters>
+{
+ double thickness=0.;
+ String name;
+ double dimensions[] = new double[3];
+ String vis;
+
+ public SiTrackerModuleParameters(Element element)
+ {
+ name = element.getAttributeValue("name");
+
+ if (element.getAttribute("vis") != null)
+ this.vis = element.getAttribute("vis").getValue();
+
+ int cntr=0;
+ for (Object o : element.getChildren("module_component"))
+ {
+ try {
+
+ Element e = (Element)o;
+
+ double thickness = e.getAttribute("thickness").getDoubleValue();
+
+ String materialName = e.getAttributeValue("material");
+
+ boolean sensitive = false;
+ if (e.getAttribute("sensitive") != null)
+ sensitive = e.getAttribute("sensitive").getBooleanValue();
+ String componentVis = null;
+ if (e.getAttribute("vis") != null)
+ componentVis = e.getAttribute("vis").getValue();
+ add(new SiTrackerModuleComponentParameters(thickness, materialName, cntr, sensitive, componentVis));
+ }
+ catch (JDOMException x)
+ {
+ throw new RuntimeException(x);
+ }
+ ++cntr;
+ }
+
+ // Optional dimension parameters (not always present).
+ if (element.getChild("trd") != null)
+ {
+ Element trd = element.getChild("trd");
+ try
+ {
+ dimensions[0] = trd.getAttribute("x1").getDoubleValue();
+ dimensions[1] = trd.getAttribute("x2").getDoubleValue();
+ dimensions[2] = trd.getAttribute("z").getDoubleValue();
+ }
+ catch (DataConversionException x)
+ {
+ throw new RuntimeException(x);
+ }
+ }
+
+ calculateThickness();
+ }
+
+ public void calculateThickness()
+ {
+ thickness = 0.; // reset thickness
+ for (SiTrackerModuleComponentParameters p : this)
+ {
+ thickness += p.getThickness();
+ }
+ }
+
+ public double getThickness()
+ {
+ return thickness;
+ }
+
+ public String getName()
+ {
+ return name;
+ }
+
+ public double getDimension(int i)
+ {
+ if (i > (dimensions.length - 1) || i < 0)
+ throw new RuntimeException("Invalid dimensions index: " + i);
+ return dimensions[i];
+ }
+
+ public String getVis()
+ {
+ return vis;
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyCoordinateSystem.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyCoordinateSystem.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyCoordinateSystem.java Tue May 5 14:05:24 2015
@@ -0,0 +1,155 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Matrix;
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.VecOp;
+
+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import org.lcsim.detector.IRotation3D;
+import org.lcsim.detector.Rotation3D;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.detector.Translation3D;
+
+ /**
+ * Class describing a simple coordinate system used to define the [log in to unmask]
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+ public class SurveyCoordinateSystem {
+ private final boolean debug = false;
+ private Hep3Vector origin;
+ private Hep3Vector u;
+ private Hep3Vector v;
+ private Hep3Vector w;
+
+// public SurveyCoordinateSystem(Hep3Vector org, Hep3Vector unit_x, Hep3Vector unit_y, Hep3Vector unit_z) {
+// origin = org;
+// u = unit_x;
+// v = unit_y;
+// w = unit_z;
+// }
+
+
+ public SurveyCoordinateSystem(Hep3Vector ball, Hep3Vector vee, Hep3Vector flat) {
+ origin = ball;
+ Hep3Vector ball_to_vee = VecOp.sub(vee, ball);
+ u = VecOp.unit(ball_to_vee);
+ Hep3Vector ball_to_flat = VecOp.sub(flat, ball);
+ w = VecOp.unit(VecOp.cross(ball_to_vee,ball_to_flat));
+ v = VecOp.cross(w, u);
+ check();
+ }
+
+ private void check() {
+ checkUnitLength();
+ checkAngles();
+ }
+
+ private void checkUnitLength() {
+ if(u.magnitude()-1>0.00001 || v.magnitude()-1>0.00001 || v.magnitude()-1>0.00001) {
+ throw new RuntimeException("Error: the unit vectors of the coordinate system is ill-defined " + toString());
+ }
+ }
+
+ private void checkAngles() {
+ if( (VecOp.dot(u, v)-1)>0.00001 || (VecOp.dot(u, w)-1)>0.00001 || (VecOp.dot(v, w)-1)>0.00001 ) {
+ throw new RuntimeException("Error: the angles in coordinate system is ill-defined " + toString());
+ }
+ }
+
+
+ /**
+ * Transform this coordinate system to another one.
+ * @param t
+ */
+ public void transform(Transform3D t) {
+ Transform3D t_this = getTransformation();
+ Hep3Vector v = t_this.getTranslation().getTranslationVector();
+ Hep3Vector vrot = t.rotated(v);
+ Hep3Vector vrottrans = t.translated(vrot);
+ origin = vrottrans;
+ rotate(t.getRotation());
+ //System.out.printf("monkey transform\n");
+ //System.out.printf("v %s\n",v.toString());
+ //System.out.printf("vrot %s\n",vrot.toString());
+ //System.out.printf("vrottrans %s\n",vrottrans.toString());
+ check();
+ }
+
+ public void rotate(IRotation3D r) {
+ r.rotate(u);
+ r.rotate(v);
+ r.rotate(w);
+ }
+
+ public void translate(Hep3Vector translation) {
+ // update origin with local translation in u,v,w
+ //origin = VecOp.add(origin, translation);
+ translate(new Translation3D(translation));
+ }
+
+ public void translate(Translation3D t) {
+ origin = t.translated(getTransformation().getTranslation().getTranslationVector());
+ }
+
+
+ public void rotateApache(Rotation r) {
+ if(debug) System.out.printf("%s: apply apache rotation to this coord system\n%s\n", getClass().getSimpleName(),toString());
+ this.u = new BasicHep3Vector(r.applyTo(new Vector3D(u.v())).toArray());
+ this.v = new BasicHep3Vector(r.applyTo(new Vector3D(v.v())).toArray());
+ this.w = new BasicHep3Vector(r.applyTo(new Vector3D(w.v())).toArray());
+ if(debug) System.out.printf("%s: new coord system after apache rotation to this coord system\n%s\n", getClass().getSimpleName(),toString());
+ }
+
+ public Hep3Vector origin() {
+ return origin;
+ }
+ public Hep3Vector u() {
+ return u;
+ }
+ public Hep3Vector v() {
+ return v;
+ }
+ public Hep3Vector w() {
+ return w;
+ }
+ public void u(Hep3Vector vec) {
+ u = vec;
+ }
+ public void v(Hep3Vector vec) {
+ v = vec;
+ }
+ public void w(Hep3Vector vec) {
+ w = vec;
+ }
+
+ public String toString() {
+ String str = "origin " + origin.toString() + "\nu " + u.toString() + "\nv " + v.toString() + "\nw " + w.toString();
+ return str;
+ }
+
+
+ /**
+ * Find @ITransform3D to the coordinate system defined by the input.
+ * @return resulting 3D transform
+ */
+ public Transform3D getTransformation() {
+ // Find the transform between the two frames - use transform classes here (not really needed)
+ Translation3D translation = new Translation3D(origin.x(), origin.y(), origin.z());
+ //RotationGeant trackingToEnvelopeRotation = new RotationGeant(0, 0, 0);
+ Rotation3D rotation = new Rotation3D(
+ new BasicHep3Matrix(
+ u.x(),v.x(),w.x(),
+ u.y(),v.y(),w.y(),
+ u.z(),v.z(),w.z()
+ ));
+ Transform3D envelopeToSupportTransform = new Transform3D(translation, rotation);
+ return envelopeToSupportTransform;
+ }
+
+
+
+
+ }
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolume.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolume.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolume.java Tue May 5 14:05:24 2015
@@ -0,0 +1,331 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.VecOp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import org.lcsim.geometry.util.TransformationUtils;
+
+/**
+ *
+ * Class containing the basic geometry information for building a volume based on survey positions.
+ *
+ */
+public abstract class SurveyVolume {
+ protected boolean debug = false;
+ private String name;
+ private String material = "Vacuum";
+ private SurveyVolume mother = null;
+ protected List<SurveyVolume> referenceGeom = null;
+ private SurveyCoordinateSystem coord;
+ protected Hep3Vector ballPos;
+ protected Hep3Vector veePos;
+ protected Hep3Vector flatPos;
+ private Hep3Vector center;
+ private Hep3Vector boxDim;
+ private AlignmentCorrection alignmentCorrections;
+
+ public SurveyVolume(String name, SurveyVolume m, AlignmentCorrection alignmentCorrection) {
+ setName(name);
+ setMother(m);
+ setAlignmentCorrection(alignmentCorrection);
+ }
+
+ public SurveyVolume(String name, SurveyVolume m, AlignmentCorrection alignmentCorrection, SurveyVolume ref) {
+ setName(name);
+ setMother(m);
+ setAlignmentCorrection(alignmentCorrection);
+ addReferenceGeom(ref);
+ }
+
+ public SurveyVolume(String name, SurveyVolume m, AlignmentCorrection alignmentCorrection, List<SurveyVolume> ref) {
+ setName(name);
+ setMother(m);
+ setAlignmentCorrection(alignmentCorrection);
+ addReferenceGeom(ref);
+ }
+
+ protected abstract void setPos();
+ protected abstract void setCenter();
+ protected abstract void setBoxDim();
+
+ protected void init() {
+ if(debug) System.out.printf("%s: init SurveyVolume %s\n",this.getClass().getSimpleName(),getName());
+ setPos();
+ setCoord();
+ applyReferenceTransformation();
+ setCenter();
+ setBoxDim();
+ applyGenericCoordinateSystemCorrections();
+ applyLocalAlignmentCorrections();
+ if(debug) {
+ //printCoordInfo();
+ System.out.printf("%s: init of SurveyVolume %s DONE\n",this.getClass().getSimpleName(),getName());
+ }
+ }
+
+
+ protected void applyGenericCoordinateSystemCorrections() {
+ //do nothing here unless overridden
+
+ }
+ protected void applyReferenceTransformation() {
+
+
+ if(referenceGeom!=null) {
+
+ if(debug) System.out.printf("%s: apply reference transformation for %s\n",this.getClass().getSimpleName(),getName());
+
+
+ if(debug) System.out.printf("%s: coord system before %d ref transformations:\n%s\n",this.getClass().getSimpleName(),referenceGeom.size(),getCoord().toString());
+
+ for(SurveyVolume ref : referenceGeom) {
+
+ if(debug) {
+ System.out.printf("%s: coord system before ref %s transform:\n%s\n",this.getClass().getSimpleName(),ref.getName(),getCoord().toString());
+ System.out.printf("%s: Ref %s coord\n%s\n",this.getClass().getSimpleName(), ref.getName(),ref.getCoord().toString());
+ }
+
+ getCoord().transform(ref.getCoord().getTransformation());
+
+ if(debug) System.out.printf("%s: coord system after ref %s transform:\n%s\n",this.getClass().getSimpleName(),ref.getName(),getCoord().toString());
+
+ }
+
+ if(debug) System.out.printf("%s: coord system after ref transformations:\n%s\n",this.getClass().getSimpleName(),getCoord().toString());
+
+ } else {
+
+ if(debug) System.out.printf("%s: no reference transformation exists for %s\n",this.getClass().getSimpleName(),getName());
+
+ }
+
+ }
+
+ private void applyLocalAlignmentCorrections() {
+ // Apply alignment corrections to local coordinate system that is already built
+ boolean debug_local = false;
+ if(this.coord==null)
+ throw new RuntimeException("no coordinate system was set before trying to apply alignment corrections.");
+
+ if(alignmentCorrections!=null) {
+
+ if(debug_local || debug) System.out.printf("%s: Apply alignment corrections to %s\n",this.getClass().getSimpleName(),this.getName());
+
+ // translate
+ if(alignmentCorrections.getTranslation()!=null) {
+
+ if(debug_local || debug) System.out.printf("%s: Apply local translation %s\n", this.getClass().getSimpleName(),alignmentCorrections.getTranslation().toString());
+
+ // rotate into mother coordinate system
+ Hep3Vector translation_mother = getCoord().getTransformation().rotated(alignmentCorrections.getTranslation());
+
+ if(debug_local || debug) System.out.printf("%s: after rotation apply translation %s to coordinate system\n", this.getClass().getSimpleName(),translation_mother.toString());
+
+ //apply translation
+ getCoord().translate(translation_mother);
+
+ } else {
+ if(debug_local || debug) System.out.printf("%s: No translation to coordinate system\n", this.getClass().getSimpleName());
+ }
+
+ // rotate
+ if(alignmentCorrections.getRotation()!=null) {
+
+ if(debug_local || debug) {
+ System.out.printf("%s: Apply rotation matrix:\n", this.getClass().getSimpleName());
+ TransformationUtils.printMatrix(alignmentCorrections.getRotation().getMatrix());
+ System.out.printf("%s: coord system before:\n%s\n", this.getClass().getSimpleName(),getCoord().toString());
+ }
+
+
+ // correct rotation of the local unit vectors
+ Vector3D u_rot_local = alignmentCorrections.getRotation().applyTo(new Vector3D(1,0,0));
+ Vector3D v_rot_local = alignmentCorrections.getRotation().applyTo(new Vector3D(0,1,0));
+ Vector3D w_rot_local = alignmentCorrections.getRotation().applyTo(new Vector3D(0,0,1));
+
+ // rotate the local unit vectors to the mother coordinates
+
+ Hep3Vector u_rot = getCoord().getTransformation().getRotation().rotated(new BasicHep3Vector(u_rot_local.toArray()));
+ Hep3Vector v_rot = getCoord().getTransformation().getRotation().rotated(new BasicHep3Vector(v_rot_local.toArray()));
+ Hep3Vector w_rot = getCoord().getTransformation().getRotation().rotated(new BasicHep3Vector(w_rot_local.toArray()));
+
+ getCoord().u(u_rot);
+ getCoord().v(v_rot);
+ getCoord().w(w_rot);
+
+ if(debug_local || debug) {
+ System.out.printf("%s: coord system after:\n%s\n", this.getClass().getSimpleName(),getCoord().toString());
+ }
+
+
+ // Do some gymnastics from Apache rotation to use the rotation class
+ //double matMP_v[][] = alignmentCorrections.getRotation().getMatrix();
+ //Hep3Matrix matMP = new BasicHep3Matrix(matMP_v[0][0], matMP_v[0][1], matMP_v[0][2],
+ // matMP_v[1][0], matMP_v[1][1], matMP_v[1][2],
+ // matMP_v[2][0], matMP_v[2][1], matMP_v[2][2]);
+ //
+ //Rotation3D rotMP = new Rotation3D(matMP);
+
+ // get the rotation correction in the mother coordinate system
+ //Rotation3D r = Rotation3D.multiply(getCoord().getTransformation().getRotation(),rotMP);
+
+// if(debug_local || debug) {
+// System.out.printf("%s: Apply rotation matrix:\n", this.getClass().getSimpleName());
+// double mat[][] = alignmentCorrections.getRotation().getMatrix();
+// TransformationUtils.printMatrix(mat);
+// System.out.printf("%s: corresponding Rotation3D object:\n%s\n",this.getClass().getSimpleName(), rotMP.toString());
+// // Get the Cardan angles of the rotation
+// double res[] = alignmentCorrections.getRotation().getAngles(RotationOrder.ZYX);
+// // Since the rotation was created based on active transformations convert to passive right here.
+// // This conversion is simply to reverse the order of rotations.
+// Hep3Vector res_passive = new BasicHep3Vector(res[2],res[1],res[0]);
+// System.out.printf("%s: Corresponding LCDD Cardan angles: %s\n", this.getClass().getSimpleName(), res_passive.toString());
+// System.out.printf("%s: Apply local to mother rotation\n%s\n",this.getClass().getSimpleName(), getCoord().getTransformation().getRotation().toString());
+// System.out.printf("%s: resulting rotation correction to apply\n%s\n",this.getClass().getSimpleName(), r.toString());
+//
+// }
+
+ // Apply correction to coordinate system
+ //getCoord().rotateApache(alignmentCorrections.getRotation());
+ //getCoord().rotate(r);
+
+ } else {
+ if(debug_local || debug) System.out.printf("%s: No rotation to coordinate system\n", this.getClass().getSimpleName());
+ }
+
+ if(debug_local || debug) System.out.printf("%s: coordinate system after alignment corrections:\n%s\n",this.getClass().getSimpleName(),getCoord().toString());
+
+ } else {
+ if(debug_local || debug) System.out.printf("%s: no alignment corrections exist for %s\n",this.getClass().getSimpleName(),this.getName());
+ }
+
+ }
+
+ private void setAlignmentCorrection(AlignmentCorrection alignmentCorrection) {
+ this.alignmentCorrections = alignmentCorrection;
+ }
+ public void setBallPos(double x, double y, double z) {
+ ballPos = new BasicHep3Vector(x,y,z);
+ }
+ public void setVeePos(double x, double y, double z) {
+ veePos = new BasicHep3Vector(x,y,z);
+ }
+ public void setFlatPos(double x, double y, double z) {
+ flatPos = new BasicHep3Vector(x,y,z);
+ }
+ public Hep3Vector getBallPos() {
+ return ballPos;
+ }
+ public Hep3Vector getVeePos() {
+ return veePos;
+ }
+ public Hep3Vector getFlatPos() {
+ return flatPos;
+ }
+ public void setCoord() {
+ if(ballPos==null || veePos==null || flatPos==null) {
+ throw new RuntimeException("Need to set ball, vee and flat before building coord system!");
+ }
+
+ coord = new SurveyCoordinateSystem(ballPos, veePos, flatPos);
+
+ if(this.debug) {
+ System.out.printf("%s: setCoord \n%s\n", this.getClass().getSimpleName(), coord.toString());
+ }
+ }
+ public SurveyCoordinateSystem getCoord() {
+ if(coord == null) {
+ throw new RuntimeException("Need to setCoord!");
+ }
+ return coord;
+ }
+ public String getName() {
+ return name;
+ }
+ public void setName(String name) {
+ this.name = name;
+ }
+ public Hep3Vector getCenter() {
+ return center;
+ }
+ public void setCenter(Hep3Vector center) {
+ this.center = center;
+ }
+ public void setCenter(double x, double y, double z) {
+ this.center = new BasicHep3Vector(x,y,z);
+ }
+ public Hep3Vector getBoxDim() {
+ return boxDim;
+ }
+ public void setBoxDim(double x, double y, double z) {
+ this.boxDim = new BasicHep3Vector(x,y,z);
+ }
+ public SurveyVolume getMother() {
+ return mother;
+ }
+ public void setMother(SurveyVolume mother) {
+ this.mother = mother;
+ }
+ public void addReferenceGeom(SurveyVolume refGeom) {
+ if(refGeom!=null) { // check that it's not a dummy call
+ if(referenceGeom == null) {
+ referenceGeom = new ArrayList<SurveyVolume>();
+ }
+ referenceGeom.add(refGeom);
+ }
+ }
+ public void addReferenceGeom(List<SurveyVolume> refGeomList) {
+ if(referenceGeom == null) {
+ referenceGeom = new ArrayList<SurveyVolume>();
+ }
+ referenceGeom.addAll(refGeomList);
+ }
+ public void printSurveyPos() {
+ if(debug) {
+ System.out.printf("%s: Survey pos for %s:\n",getClass().getSimpleName(),getName());
+ System.out.printf("%s: ballPos %s\n",getClass().getSimpleName(), ballPos.toString());
+ System.out.printf("%s: veePos %s\n",getClass().getSimpleName(), veePos.toString());
+ System.out.printf("%s: flatPos %s\n",getClass().getSimpleName(), flatPos.toString());
+ }
+ }
+ public String getMaterial() {
+ return material;
+ }
+ public void setMaterial(String material) {
+ this.material = material;
+ }
+ public String toString() {
+ String s = "==\n" + getName() + " with mother " + (getMother()==null?"<no mother>":getMother().getName()) + ":\n";
+ if( getCenter()!=null) s += "Center of box: " + getCenter().toString() + "\n";
+ if( getBoxDim()!=null) s += "Box dimensions: " + getBoxDim().toString() + "\n";
+ if(this.coord==null) s += " No coord system \n";
+ else s += "Coordinate system:" + getCoord().toString() + "\n";
+ SurveyVolume m = getMother();
+ while(m!=null) {
+ Hep3Vector origin_m = HPSTrackerBuilder.transformToParent(new BasicHep3Vector(0, 0, 0), this, m.getName());
+ s += String.format("%s origin in %s : %s (mm)\n",getName(), m.getName(), origin_m.toString());
+ origin_m = VecOp.mult(0.0393701, origin_m);
+ s += String.format("%s origin in %s : (%.4f %.4f %.4f) (inch)\n",getName(), m.getName(), origin_m.x(),origin_m.y(),origin_m.z());
+ m = m.getMother();
+ }
+
+ return s;
+ }
+
+// private void printCoordInfo() {
+// if(debug) {
+// SurveyVolume m = getMother();
+// while(m!=null) {
+// Hep3Vector origin_m = HPSTrackerBuilder.transformToParent(getCoord().origin(), this, m.getName());
+// System.out.printf("%s: %s final coord system in %s : %s\n",this.getClass().getSimpleName(),getName(), getMother()==null?" <no mother> ":getMother().getName(),getCoord().toString());
+// }
+// System.out.printf("%s: init of SurveyVolume %s DONE\n",this.getClass().getSimpleName(),getName());
+// }
+// }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeImpl.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeImpl.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeImpl.java Tue May 5 14:05:24 2015
@@ -0,0 +1,41 @@
+package org.lcsim.geometry.compact.converter;
+
+import hep.physics.vec.Hep3Vector;
+
+public abstract class SurveyVolumeImpl extends SurveyVolumeVisualization {
+
+ private boolean debug = false;
+ protected SurveyVolume surveyVolume = null;
+
+ public SurveyVolumeImpl(SurveyVolume surveyVolume) {
+ super();
+ this.surveyVolume = surveyVolume;
+ }
+
+ public abstract void buildPhysVolume();
+
+ public abstract void buildBox();
+
+ public abstract void buildVolume();
+
+ public abstract void setPositionAndRotation(SurveyVolume base);
+
+ public String getName() {
+ return surveyVolume.getName();
+ }
+
+ protected Hep3Vector getBoxDim() {
+ return surveyVolume.getBoxDim();
+ }
+
+ protected String getMaterial() {
+ return surveyVolume.getMaterial();
+ }
+
+ public boolean isDebug() {
+ return debug;
+ }
+
+ public abstract String toString();
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeVisualization.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeVisualization.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SurveyVolumeVisualization.java Tue May 5 14:05:24 2015
@@ -0,0 +1,20 @@
+package org.lcsim.geometry.compact.converter;
+
+/**
+ *
+ * LCDD geometry visualization information
+ *
+ * @author Per Hansson Adrian <[log in to unmask]>
+ */
+public class SurveyVolumeVisualization {
+ protected String visName = "";
+ public SurveyVolumeVisualization() {}
+ public String getVisName() {
+ return visName;
+ }
+ protected void setVisName(String visName) {
+ this.visName = visName;
+ }
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SvtAlignmentConstantsReader.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SvtAlignmentConstantsReader.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/SvtAlignmentConstantsReader.java Tue May 5 14:05:24 2015
@@ -0,0 +1,44 @@
+package org.lcsim.geometry.compact.converter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.hps.conditions.database.DatabaseConditionsManager;
+import org.hps.conditions.svt.SvtAlignmentConstant;
+import org.hps.conditions.svt.SvtAlignmentConstant.SvtAlignmentConstantCollection;
+import org.lcsim.conditions.ConditionsManager;
+
+/**
+ * Reads in SVT alignment constants from the database and converts them to the {@link MilleParameter} class expected by
+ * the detector model.
+ *
+ * @author <a href="mailto:[log in to unmask]">Jeremy McCormick</a>
+ */
+public class SvtAlignmentConstantsReader {
+
+ public List<MilleParameter> readMilleParameters() {
+
+ if (!ConditionsManager.isSetup()) {
+ throw new RuntimeException("Conditions system is not initialized.");
+ }
+
+ final DatabaseConditionsManager manager = DatabaseConditionsManager.getInstance();
+
+ System.out.printf("loading alignment parameters with detector: %s; run: %d", manager.getDetector(),
+ manager.getRun());
+
+ final List<MilleParameter> milleParameters = new ArrayList<MilleParameter>();
+
+ final SvtAlignmentConstantCollection alignmentConstants = manager.getCachedConditions(
+ SvtAlignmentConstantCollection.class, "svt_alignments").getCachedData();
+
+ for (final SvtAlignmentConstant constant : alignmentConstants) {
+ final MilleParameter p = new MilleParameter(Integer.parseInt(constant.getParameter()), constant.getValue(),
+ 0.0);
+ milleParameters.add(p);
+ System.out.println("added " + p.toString());
+ }
+
+ return milleParameters;
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014.java Tue May 5 14:05:24 2015
@@ -0,0 +1,1444 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import static java.lang.Math.PI;
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014GeometryDefinition;
+import org.lcsim.geometry.compact.converter.HPSTestRunTracker2014LCDDBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerGeometryDefinition;
+import org.lcsim.geometry.compact.converter.HPSTrackerLCDDBuilder;
+import org.lcsim.geometry.compact.converter.lcdd.util.Box;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.PhysVol;
+import org.lcsim.geometry.compact.converter.lcdd.util.Position;
+import org.lcsim.geometry.compact.converter.lcdd.util.Rotation;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+import org.lcsim.geometry.util.TransformationUtils;
+
+
+/**
+ *
+ * Convert the HPS Test run tracker 2014 to the LCDD format.
+ *
+ * @author Per Hansson <[log in to unmask]>
+ *
+ */
+public class HPSTestRunTracker2014 extends HPSTracker2014Base
+{
+ public HPSTestRunTracker2014(Element node) throws JDOMException
+ {
+ super(node);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.lcdd.HPSTracker2014Base#initializeBuilder(org.lcsim.geometry.compact.converter.lcdd.util.LCDD, org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector)
+ */
+ protected HPSTrackerLCDDBuilder initializeBuilder(LCDD lcdd, SensitiveDetector sens) {
+ HPSTrackerLCDDBuilder b = new HPSTestRunTracker2014LCDDBuilder(_debug,node,lcdd,sens);
+ return b;
+ }
+
+
+
+ /* (non-Javadoc)
+ * @see org.lcsim.detector.converter.compact.HPSTracker2014ConverterBase#getModuleNumber(org.lcsim.geometry.compact.converter.JavaSurveyVolume)
+ */
+ protected int getModuleNumber(String surveyVolume) {
+ return HPSTrackerBuilder.getHalfFromName(surveyVolume).equals("top") ? 0 : 1;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ private void makeExample(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample ----");
+
+ }
+
+
+
+ String volName = "example";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisX = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(1., 0., 0.);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisY = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(0., 1., 0.);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisZ = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(0., 0., 1.);
+
+ double alpha1 = PI / 4.;
+ double alpha2 = PI / 4.;
+ double alpha3 = -PI / 4.;
+
+ //set up a rotation by alpha1 about the X axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r1 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(axisX, alpha1);
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisYPrime = r1.applyTo(axisY);
+ //org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisZPrime = r1.applyTo(axisZ);
+
+ if(_debug) System.out.println("axisYPrime: " + axisYPrime);
+ //if(_debug) System.out.println("axisZPrime: " + axisZPrime);
+
+ //set up a rotation by alpha2 about the Y' axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r2 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(axisYPrime, alpha2);
+
+ //find z''
+ //org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisZPrimePrime = r2.applyTo(axisZPrime);
+ //if(_debug) System.out.println("axisZPrimePrime: " + axisZPrimePrime);
+
+
+
+ //set up a rotation by alpha3 about the Z'' axis
+ //org.apache.commons.math3.geometry.euclidean.threed.Rotation r3 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(axisZPrimePrime, alpha3);
+
+ if(_debug) System.out.println("r1 (XYZ): " + r1.toString());
+
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r12 = r2.applyTo(r1);
+
+ //find z''
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisZPrimePrime = r12.applyTo(axisZ);
+ if(_debug) System.out.println("axisZPrimePrime: " + axisZPrimePrime);
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r3 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(axisZPrimePrime, alpha3);
+
+
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r123 = r3.applyTo(r12);
+
+ //double [] rotations = r12.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+ double [] rotations = r123.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5,0,0);
+ //Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ Rotation rot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+ private void makeExample2(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample2 ----");
+
+ }
+
+ String volName = "example2";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisX = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(1., 0., 0.);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisY = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(0., 1., 0.);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisZ = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(0., 0., 1.);
+
+ double alpha1 = PI / 4.;
+ double alpha2 = PI / 4.;
+ double alpha3 = -PI / 4.;
+
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r123 =
+ new org.apache.commons.math3.geometry.euclidean.threed.Rotation(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ,
+ alpha1,
+ alpha2,
+ alpha3);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisXPrime = r123.applyTo(axisX);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisYPrime = r123.applyTo(axisY);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D axisZPrime = r123.applyTo(axisZ);
+
+ //if(_debug) System.out.println("axisYPrime: " + axisYPrime);
+ //if(_debug) System.out.println("axisZPrime: " + axisZPrime);
+
+
+
+ //double [] rotations = r123.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+
+ //double [] rotations = r12.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+ double [] rotations = r123.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5,0,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+ private void makeExample3(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample3 ----");
+
+ }
+
+ String volName = "example3";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+ /*
+
+ TestRunModuleL13: survey positions before ref support_plate_top transform
+ Survey pos for module_L1t:
+ ballPos [ 25.000, 676.10, -4.3500]
+ veePos [ 95.000, 676.10, -4.3500]
+ flatPos [ 60.000, 670.10, -4.3500]
+ TestRunModuleL13: Ref support_plate_top coord
+ Coordinate system:
+ origin [ 40.314, 142.71, 138.40]
+ u [ 0.99955, 0.030000, 0.0000]
+ v [ -0.030000, 0.99955, 0.0000]
+ w [ 0.0000, -0.0000, 1.0000]
+ TestRunModuleL13: survey positions after ref support_plate_top transform
+ Survey pos for module_L1t:
+ ballPos [ 45.020, 819.25, 134.05]
+ veePos [ 114.99, 821.35, 134.05]
+ flatPos [ 80.184, 814.31, 134.05]
+ TestRunModuleL13: coordinate system:
+ Coordinate system:
+ origin [ 45.020, 819.25, 134.05]
+ u [ 0.99955, 0.030000, 0.0000]
+ v [ 0.030000, -0.99955, 0.0000]
+ w [ 0.0000, 0.0000, -1.0000]
+ TestRunModuleL13: translation:
+ [ 45.020, 819.25, 134.05]
+ TestRunModuleL13: rotation:
+ [
+ 0.999549894704642 0.030000133265350216 0.0
+ 0.030000133265350216 -0.999549894704642 0.0
+ 0.0 0.0 -1.0
+
+ ]
+
+
+
+ LCDDBaseGeom: set position and rotation for volume module_L1t
+getEulerAngles: u [ 0.030000, -0.99955, 0.0000] v[ 0.0000, 0.0000, -1.0000] -> [ 0.0000, 1.0000, 0.0000] [ 0.0000, 0.0000, 1.0000]
+Input: u {0.03; -1; 0} v {0; 0; -1} u' {0; 1; 0} v' {0; 0; 1}
+rot matrix:
+ 0.999550 0.030000 0.000000
+ 0.030000 -0.999550 0.000000
+ 0.000000 0.000000 -1.000000
+Resulting XYZ angles [ -3.1416, 0.0000, -0.030005]
+LCDDBaseGeom: box_center_base_local [ 97.600, 0.0000, 29.150]
+LCDDBaseGeom: box_center_base [ 142.58, 822.18, 104.90]
+LCDDBaseGeom: mother center [ 192.50, 608.00, 81.550]
+LCDDBaseGeom: box_center [ -49.924, 214.18, 23.350]
+LCDDBaseGeom: pos [Element: <position/>]
+LCDDBaseGeom: euler [ -3.1416, 0.0000, -0.030005]
+LCDDBaseGeom: rot [Element: <rotation/>]
+LCDDBaseGeom: DONE constructing LCDD object module_L1t
+
+
+
+ */
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ Hep3Vector u_L1 = new BasicHep3Vector(0.99955, 0.030000, 0.0000);
+ Hep3Vector v_L1 = new BasicHep3Vector(0.030000, -0.99955, 0.0000);
+ Hep3Vector w_L1 = new BasicHep3Vector(0.0000, 0.0000, -1.0000);
+
+
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_L1 = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u_L1.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_L1 = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v_L1.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_L1 = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w_L1.v());
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+ Hep3Vector euler_angles = TransformationUtils.getCardanAngles(v_L1, w_L1, v, w);
+
+ //Get the generic rotation
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(v_3D_L1,w_3D_L1,v_3D, w_3D);
+ //Get the angles
+ double rotations[] = r.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+ if(_debug) {
+ System.out.println("getEulerAngles gives euler_angles: " + euler_angles.toString());
+ System.out.println("manual gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+ }
+
+ if((rotations[0]-euler_angles.x())>0.00001 || (rotations[1]-euler_angles.y())>0.00001 || (rotations[2]-euler_angles.z())>0.00001) {
+ //System.("closing the loop in apache rotation didn't work!");
+ //throw new RuntimeException("closing the loop in apache rotation didn't work!");
+ }
+
+
+
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*4,0,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("HybridVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+ private void makeExample4(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample4 ----");
+
+ }
+
+ String volName = "example4";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+
+
+ //set up a rotation about the X axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r1 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(u_3D, -1.0*Math.PI);
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_p = r1.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_p = r1.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_p = r1.applyTo(w_3D);
+
+
+ double [] rotations = r1.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+
+ if(_debug) {
+ System.out.println("u_3D: " + u_3D.toString());
+ System.out.println("v_3D: " + v_3D.toString());
+ System.out.println("w_3D: " + w_3D.toString());
+ r1.toString();
+ System.out.println("u_3D_p: " + u_3D_p.toString());
+ System.out.println("v_3D_p: " + v_3D_p.toString());
+ System.out.println("w_3D_p: " + w_3D_p.toString());
+
+ System.out.println("gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*2,0,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+ private void makeExample5(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample5 ----");
+
+ }
+
+ String volName = "example5";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+
+
+ //set up a rotation about the X axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r1 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(u_3D, -1.0*Math.PI);
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_p = r1.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_p = r1.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_p = r1.applyTo(w_3D);
+
+ // set up a rotation about the Z axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r3 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(w_3D_p, -0.03);
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r13 = r3.applyTo(r1);
+
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_pp = r13.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_pp = r13.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_pp = r13.applyTo(w_3D);
+ //org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_pp = r13.applyTo(u_3D_p);
+ //org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_pp = r13.applyTo(v_3D_p);
+ //org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_pp = r13.applyTo(w_3D_p);
+
+ double [] rotations = r13.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+
+ if(_debug) {
+ System.out.println("u_3D: " + u_3D.toString());
+ System.out.println("v_3D: " + v_3D.toString());
+ System.out.println("w_3D: " + w_3D.toString());
+ r1.toString();
+ System.out.println("u_3D_p: " + u_3D_p.toString());
+ System.out.println("v_3D_p: " + v_3D_p.toString());
+ System.out.println("w_3D_p: " + w_3D_p.toString());
+ r13.toString();
+ System.out.println("u_3D_pp: " + u_3D_pp.toString());
+ System.out.println("v_3D_pp: " + v_3D_pp.toString());
+ System.out.println("w_3D_pp: " + w_3D_pp.toString());
+ System.out.println("gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*3,0,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+
+ private void makeExample5b(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample5b ----");
+
+ }
+
+ String volName = "example5b";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+
+ // set up a rotation about the Z axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r3 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(w_3D, -0.03);
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_p = r3.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_p = r3.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_p = r3.applyTo(w_3D);
+
+
+
+ double [] rotations = r3.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+
+ if(_debug) {
+ System.out.println("u_3D: " + u_3D.toString());
+ System.out.println("v_3D: " + v_3D.toString());
+ System.out.println("w_3D: " + w_3D.toString());
+ r3.toString();
+ System.out.println("u_3D_p: " + u_3D_p.toString());
+ System.out.println("v_3D_p: " + v_3D_p.toString());
+ System.out.println("w_3D_p: " + w_3D_p.toString());
+ System.out.println("gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*3,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-1.5,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+ private void makeExample3b(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample3b ----");
+
+ }
+
+ String volName = "example3b";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+ /*
+
+ TestRunModuleL13: survey positions
+Survey pos for module_L1b:
+ballPos [ 25.000, 661.10, 4.3500]
+veePos [ 95.000, 661.10, 4.3500]
+flatPos [ 60.000, 667.10, 4.3500]
+TestRunModuleL13: survey positions before ref support_plate_bottom transform
+Survey pos for module_L1b:
+ballPos [ 25.000, 661.10, 4.3500]
+veePos [ 95.000, 661.10, 4.3500]
+flatPos [ 60.000, 667.10, 4.3500]
+TestRunModuleL13: Ref support_plate_bottom coord
+Coordinate system:
+origin [ 40.314, 142.71, 22.700]
+u [ 0.99955, 0.030000, 0.0000]
+v [ -0.030000, 0.99955, 0.0000]
+w [ 0.0000, -0.0000, 1.0000]
+TestRunModuleL13: survey positions after ref support_plate_bottom transform
+Survey pos for module_L1b:
+ballPos [ 45.470, 804.26, 27.050]
+veePos [ 115.44, 806.36, 27.050]
+flatPos [ 80.274, 811.31, 27.050]
+TestRunModuleL13: coordinate system:
+Coordinate system:
+origin [ 45.470, 804.26, 27.050]
+u [ 0.99955, 0.030000, 0.0000]
+v [ -0.030000, 0.99955, 0.0000]
+w [ 0.0000, 0.0000, 1.0000]
+TestRunModuleL13: translation:
+[ 45.470, 804.26, 27.050]
+TestRunModuleL13: rotation:
+[
+0.9995498947046422 -0.030000133265350216 0.0
+0.030000133265350216 0.9995498947046422 0.0
+0.0 0.0 1.0
+
+]
+
+
+
+
+
+ LCDDBaseGeom: set position and rotation for volume module_L1b
+getEulerAngles: u [ -0.030000, 0.99955, 0.0000] v[ 0.0000, 0.0000, 1.0000] -> [ 0.0000, 1.0000, 0.0000] [ 0.0000, 0.0000, 1.0000]
+Input: u {-0.03; 1; 0} v {0; 0; 1} u' {0; 1; 0} v' {0; 0; 1}
+rot matrix:
+ 0.999550 0.030000 0.000000
+ -0.030000 0.999550 -0.000000
+ -0.000000 0.000000 1.000000
+Resulting XYZ angles [ 0.0000, 0.0000, -0.030005]
+LCDDBaseGeom: box_center_base_local [ 97.600, 0.0000, 29.150]
+LCDDBaseGeom: box_center_base [ 143.03, 807.19, 56.200]
+LCDDBaseGeom: mother center [ 192.50, 608.00, 81.550]
+LCDDBaseGeom: box_center [ -49.474, 199.19, -25.350]
+LCDDBaseGeom: pos [Element: <position/>]
+LCDDBaseGeom: euler [ 0.0000, 0.0000, -0.030005]
+LCDDBaseGeom: rot [Element: <rotation/>]
+LCDDBaseGeom: DONE constructing LCDD object module_L1b
+
+
+
+
+
+ */
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ Hep3Vector u_L1 = new BasicHep3Vector(0.99955, 0.030000, 0.0000);
+ Hep3Vector v_L1 = new BasicHep3Vector(-0.030000, 0.99955, 0.0000);
+ Hep3Vector w_L1 = new BasicHep3Vector(0.0000, 0.0000, 1.0000);
+
+
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_L1 = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u_L1.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_L1 = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v_L1.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_L1 = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w_L1.v());
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+ Hep3Vector euler_angles = TransformationUtils.getCardanAngles(v_L1, w_L1, v, w);
+
+ //Get the generic rotation
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(v_3D_L1,w_3D_L1,v_3D, w_3D);
+ //Get the angles
+ double rotations[] = r.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+ if(_debug) {
+ System.out.println("getEulerAngles gives euler_angles: " + euler_angles.toString());
+ System.out.println("manual gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+ }
+
+ if((rotations[0]-euler_angles.x())>0.00001 || (rotations[1]-euler_angles.y())>0.00001 || (rotations[2]-euler_angles.z())>0.00001) {
+ //throw new RuntimeException("closing the loop in apache rotation didn't work!");
+ }
+
+
+
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*4,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-1.5,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("HybridVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+ private void makeExample6(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample6 ----");
+
+ }
+
+ String volName = "example6";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+ double [] rotations = {-0.5*Math.PI,0,0};
+
+
+ if(_debug) {
+
+
+ System.out.println("manual set lcdd angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-2,0,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+ private void makeExample66(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample66 ----");
+
+ }
+
+ String volName = "example66";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+
+
+ //set up a rotation about the X axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r1 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(u_3D, -0.5*Math.PI);
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_p = r1.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_p = r1.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_p = r1.applyTo(w_3D);
+
+
+ double [] rotations = r1.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+
+ if(_debug) {
+ System.out.println("u_3D: " + u_3D.toString());
+ System.out.println("v_3D: " + v_3D.toString());
+ System.out.println("w_3D: " + w_3D.toString());
+ r1.toString();
+ System.out.println("u_3D_p: " + u_3D_p.toString());
+ System.out.println("v_3D_p: " + v_3D_p.toString());
+ System.out.println("w_3D_p: " + w_3D_p.toString());
+
+ System.out.println("gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-4,0,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+
+
+
+ private void makeExample7(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample7 ----");
+
+ }
+
+ String volName = "example7";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+ double [] rotations = {-0.5*Math.PI,0,-0.25*Math.PI};
+
+
+ if(_debug) {
+
+
+ System.out.println("manual set lcdd angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-2,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-1,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+ private void makeExample77(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample77 ----");
+
+ }
+
+ String volName = "example77";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+
+
+ //set up a rotation about the X axis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r1 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(u_3D, -0.5*Math.PI);
+
+ // find y' and z'
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_p = r1.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_p = r1.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_p = r1.applyTo(w_3D);
+
+
+ //set up a rotation about the Z xis
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r3 = new org.apache.commons.math3.geometry.euclidean.threed.Rotation(w_3D_p, -0.25*Math.PI);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Rotation r13 = r3.applyTo(r1);
+
+ // find y'' and z''
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_pp = r13.applyTo(u_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_pp = r13.applyTo(v_3D);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_pp = r13.applyTo(w_3D);
+
+ // find y'' and z'' (cross-check)
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D_pp_2 = r3.applyTo(u_3D_p);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D_pp_2 = r3.applyTo(v_3D_p);
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D_pp_2 = r3.applyTo(w_3D_p);
+
+
+ double [] rotations = r13.getAngles(org.apache.commons.math3.geometry.euclidean.threed.RotationOrder.XYZ);
+
+
+ if(_debug) {
+ System.out.println("u_3D: " + u_3D.toString());
+ System.out.println("v_3D: " + v_3D.toString());
+ System.out.println("w_3D: " + w_3D.toString());
+ r1.toString();
+ System.out.println("u_3D_p: " + u_3D_p.toString());
+ System.out.println("v_3D_p: " + v_3D_p.toString());
+ System.out.println("w_3D_p: " + w_3D_p.toString());
+ r13.toString();
+ System.out.println("u_3D_pp: " + u_3D_pp.toString());
+ System.out.println("v_3D_pp: " + v_3D_pp.toString());
+ System.out.println("w_3D_pp: " + w_3D_pp.toString());
+
+ System.out.println("gives euler_angles: (" + rotations[0] + "," + rotations[1] + "," + rotations[2] + ")");
+
+ System.out.println("u_3D_pp_2: " + u_3D_pp_2.toString());
+ System.out.println("v_3D_pp_2: " + v_3D_pp_2.toString());
+ System.out.println("w_3D_pp_2: " + w_3D_pp_2.toString());
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-4,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-1,0);
+ Rotation rot = new Rotation(volName + "_rotation",rotations[0],rotations[1],rotations[2]);
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+
+ private void makeExample8(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample8 ----");
+
+ }
+
+ String volName = "example8";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+ Hep3Vector u_L1 = new BasicHep3Vector(1/Math.sqrt(2),0,1/Math.sqrt(2));
+ Hep3Vector v_L1 = new BasicHep3Vector(-1/Math.sqrt(2),0,1/Math.sqrt(2));
+ Hep3Vector w_L1 = new BasicHep3Vector(0,-1,0);
+
+ Hep3Vector euler_angles = TransformationUtils.getCardanAngles(u_L1, v_L1, u, v);
+
+
+
+
+ if(_debug) {
+
+
+ System.out.println("euler angles " + euler_angles.toString());
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-1,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-3,0);
+ Rotation rot = new Rotation(volName + "_rotation",euler_angles.x(),euler_angles.y(),euler_angles.z());
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+ private void makeExample9(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample9 ----");
+
+ }
+
+ String volName = "example9";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+ Hep3Vector u_L1 = new BasicHep3Vector(1,0,0);
+ Hep3Vector v_L1 = new BasicHep3Vector(0,0,1);
+ Hep3Vector w_L1 = new BasicHep3Vector(0,-1,0);
+
+ Hep3Vector euler_angles = TransformationUtils.getCardanAngles(u_L1, v_L1, u, v);
+
+
+
+
+ if(_debug) {
+
+
+ System.out.println("euler angles " + euler_angles.toString());
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-1,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-2,0);
+ Rotation rot = new Rotation(volName + "_rotation",euler_angles.x(),euler_angles.y(),euler_angles.z());
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+
+
+ private void makeExample10(LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeExample10 ----");
+
+ }
+
+ String volName = "example10";
+ Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/4.0);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+ Hep3Vector u = new BasicHep3Vector(1,0,0);
+ Hep3Vector v = new BasicHep3Vector(0,1,0);
+ Hep3Vector w = new BasicHep3Vector(0,0,1);
+
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D u_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(u.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D v_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(v.v());
+ org.apache.commons.math3.geometry.euclidean.threed.Vector3D w_3D = new org.apache.commons.math3.geometry.euclidean.threed.Vector3D(w.v());
+
+ Hep3Vector u_L1 = new BasicHep3Vector(1/Math.sqrt(2),1/Math.sqrt(2),0);
+ Hep3Vector v_L1 = new BasicHep3Vector(0,0,1);
+ Hep3Vector w_L1 = new BasicHep3Vector(1/Math.sqrt(2),-1/Math.sqrt(2),0);
+
+ Hep3Vector euler_angles = TransformationUtils.getCardanAngles(u_L1, v_L1, u, v);
+
+
+
+
+ if(_debug) {
+
+
+ System.out.println("euler angles " + euler_angles.toString());
+
+ }
+
+
+
+ //apply to unit vector
+
+ Position pos = new Position(volName + "_position",HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width*1.5*-2,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*-2,0);
+ Rotation rot = new Rotation(volName + "_rotation",euler_angles.x(),euler_angles.y(),euler_angles.z());
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+
+ PhysVol basePV = new PhysVol(volume, lcdd.pickMotherVolume(this), pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+
+
+
+ volName = volName + "_sub";
+ Box boxSub = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0 , HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/8.0);
+ lcdd.add(boxSub);
+ Volume volumeSub = new Volume(volName + "_volume", boxSub, lcdd.getMaterial("Vacuum"));
+ Position subPos = new Position(volName + "_position",0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/4.0*2-HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length/8.0,HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_height/16.0);
+ Rotation subRot = new Rotation(volName + "_rotation",0,0,0);
+ lcdd.add(subPos);
+ lcdd.add(subRot);
+ PhysVol subBasePV = new PhysVol(volumeSub, volume, subPos, subRot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + subBasePV.getName());
+ }
+
+ lcdd.add(volumeSub);
+ volumeSub.setVisAttributes(lcdd.getVisAttributes("SensorVis"));
+
+ lcdd.add(volume);
+
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014.java Tue May 5 14:05:24 2015
@@ -0,0 +1,71 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.geometry.compact.converter.HPSTracker2014LCDDBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerLCDDBuilder;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+
+/**
+ *
+ * Convert the HPS Test run tracker 2014 to the LCDD format.
+ *
+ * @author Per Hansson <[log in to unmask]>
+ *
+ */
+public class HPSTracker2014 extends HPSTracker2014Base
+{
+ public HPSTracker2014(Element node) throws JDOMException
+ {
+ super(node);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.lcdd.HPSTracker2014Base#initializeBuilder(org.lcsim.geometry.compact.converter.lcdd.util.LCDD, org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector)
+ */
+ protected HPSTrackerLCDDBuilder initializeBuilder(LCDD lcdd, SensitiveDetector sens) {
+ HPSTrackerLCDDBuilder b = new HPSTracker2014LCDDBuilder(_debug,node,lcdd,sens);
+ return b;
+ }
+
+ protected int getModuleNumber(String surveyVolume) {
+ boolean isTopLayer = HPSTrackerBuilder.getHalfFromName(surveyVolume).equals("top") ? true : false;
+ int layer = HPSTrackerBuilder.getLayerFromVolumeName(surveyVolume);
+ int moduleNumber = -1;
+ if(isTopLayer) {
+ if(layer < 4 ) {
+ moduleNumber = 0;
+ } else {
+ if(HPSTrackerBuilder.isHoleFromName(surveyVolume)) {
+ moduleNumber = 2;
+ } else {
+ moduleNumber = 0;
+ }
+ }
+ } else {
+ if(layer < 4 ) {
+ moduleNumber = 1;
+ } else {
+ if(HPSTrackerBuilder.isHoleFromName(surveyVolume)) {
+ moduleNumber = 1;
+ } else {
+ moduleNumber = 3;
+ }
+ }
+ }
+
+ if(moduleNumber<0) throw new RuntimeException("Invalid module nr found for " + surveyVolume);
+
+ return moduleNumber;
+ }
+
+
+
+}
+
+
+
+
+
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014Base.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014Base.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014Base.java Tue May 5 14:05:24 2015
@@ -0,0 +1,383 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import java.util.Iterator;
+
+import org.jdom.DataConversionException;
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.geometry.compact.converter.HPSTrackerBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerLCDDBuilder;
+import org.lcsim.geometry.compact.converter.LCDDGhostSurveyVolume;
+import org.lcsim.geometry.compact.converter.LCDDSurveyVolume;
+import org.lcsim.geometry.compact.converter.SurveyCoordinateSystem;
+import org.lcsim.geometry.compact.converter.lcdd.util.Box;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.PhysVol;
+import org.lcsim.geometry.compact.converter.lcdd.util.Position;
+import org.lcsim.geometry.compact.converter.lcdd.util.Rotation;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+import org.lcsim.geometry.compact.converter.lcdd.util.Volume;
+import org.lcsim.geometry.util.TransformationUtils;
+
+/**
+ *
+ * Convert an HPS tracker "2014" to the LCDD format.
+ *
+ * @author Per Hansson <[log in to unmask]>
+ *
+ */
+public abstract class HPSTracker2014Base extends LCDDSubdetector {
+
+ protected boolean _debug = true;
+ protected static HPSTrackerLCDDBuilder builder;
+ private final boolean buildBeamPlane = false;
+ private final double beamPlaneWidth = 385.00;
+ private final double beamPlaneLength = 1216.00;
+ private final double beamPlaneThickness = 0.00000001;
+
+ public HPSTracker2014Base(Element c) throws JDOMException {
+ super(c);
+ }
+
+
+ /**
+ * Set the @HPSTrackerLCDDBuilder for this converter.
+ * @param lcdd
+ * @param sens
+ * @return the builder.
+ */
+ abstract protected HPSTrackerLCDDBuilder initializeBuilder(LCDD lcdd, SensitiveDetector sens);
+
+
+ public boolean isTracker() {
+ return true;
+ }
+
+ /**
+ * Build the LCDD for the subdetector.
+ * @param lcdd - the LCDD file being created.
+ * @param sens - the SD for this subdetector.
+ */
+
+ public void addToLCDD(LCDD lcdd, SensitiveDetector sens) throws JDOMException
+ {
+
+
+
+ /// General comments
+ // Roll: rotation around x
+ // pitch: rotation around y
+ // yaw: rotation around z
+
+ // kinematic mounts:
+ // ball (constraints x,y,z)
+ // vee (constraints pitch & yaw)
+ // flat (constraints roll)
+ ///
+
+
+
+ // ID of the detector.
+ int id = node.getAttribute("id").getIntValue();
+
+ // Name of the detector.
+ String detector_name = node.getAttributeValue("name");
+
+ if(_debug) System.out.printf("%s: detector id %d name %s",getClass().getSimpleName(), id,detector_name);
+
+
+ // Pick the mother volume (tracking volume).
+ Volume trackingVolume = lcdd.pickMotherVolume(this);
+
+
+ if(_debug) System.out.printf("%s: setup and build the LCDD geometry\n", getClass().getSimpleName());
+
+ // setup and build the LCDD geometry
+ builder = initializeBuilder(lcdd, sens);
+ //builder = new HPSTestRunTracker2014LCDDBuilder(_debug,node,lcdd,sens);
+
+ //builder.setLCDD(lcdd);
+ //builder.setSensitiveDetector(sens);
+ builder.build(trackingVolume);
+
+ if(_debug) System.out.printf("%s: DONE setup and build the LCDD geometry\n", getClass().getSimpleName());
+
+
+
+ if(buildBeamPlane ) {
+ makeBeamPlane(trackingVolume, lcdd, sens);
+ }
+
+
+ // Actually build the LCDD
+ setupPhysicalVolumes();
+
+
+ }
+
+
+
+
+ /**
+ * Top function to add objects to the LCDD file using the geometry builder class.
+ */
+ protected void setupPhysicalVolumes() {
+
+ if(_debug) System.out.printf("%s: buildLCDD\n", getClass().getSimpleName());
+
+ // Get a reference to the LCDD
+ LCDD lcdd = builder.getLCDD();
+ SensitiveDetector sd = builder.getSensitiveDetector();
+
+ // Reference to the top level object in the builder class
+ // In this case it is the base volume holding the entire tracker
+ LCDDSurveyVolume lcddObj = (LCDDSurveyVolume) builder.getBaseLCDD();
+
+ // Add the base volume and all its daughters to the LCDD
+ setupPhysicalVolumes(lcddObj,lcdd,sd);
+
+ if(_debug) System.out.printf("%s: buildLCDD DONE\n", getClass().getSimpleName());
+
+ }
+
+
+
+ /**
+ * Add a @LCDDBaseGeom geometry object to the LCDD file.
+ * @param lcddObj to add
+ * @param lcdd file
+ */
+ private void setupPhysicalVolumes(LCDDSurveyVolume lcddObj, LCDD lcdd, SensitiveDetector sd) {
+
+ if(_debug) System.out.printf("%s: adding %s to LCDD\n", getClass().getSimpleName(),lcddObj.getName());
+
+ boolean validLCDD = true;
+
+ if(lcddObj instanceof LCDDGhostSurveyVolume) {
+
+ if(_debug) System.out.printf("%s: %s is a ghost volume, don't add to LCDD\n", getClass().getSimpleName(),lcddObj.getName());
+ validLCDD = false;
+
+ } else {
+
+ // Special case for top level volume which is a non-ghost but is already there.
+ if(lcddObj.getName().contains("tracking")) {
+
+ if(_debug) System.out.printf("%s: %s is the tracking volume, don't add to LCDD\n", getClass().getSimpleName(),lcddObj.getName());
+ validLCDD = false;
+
+ } else {
+
+ //X-check
+ if(lcddObj instanceof LCDDGhostSurveyVolume )
+ throw new RuntimeException("trying to add a ghost volume (" + lcddObj.getName() + ") to LCDD!?");
+
+ // add box, pos, rotation and create phys volume
+ lcdd.add(lcddObj.getBox());
+ lcdd.add(lcddObj.getPos());
+ lcdd.add(lcddObj.getRot());
+ lcddObj.buildPhysVolume();
+
+ // setup the properties of the phys volume
+ try {
+ setPhysicalVolumeProperties(lcddObj, sd);
+ } catch (DataConversionException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ // add daughters to this volume
+
+ if(_debug) System.out.printf("%s: add %d daughters to %s\n", getClass().getSimpleName(),lcddObj.getDaughters().size(),lcddObj.getName());
+
+ for(LCDDSurveyVolume daughter : lcddObj.getDaughters()) {
+ setupPhysicalVolumes(daughter,lcdd, sd);
+ }
+
+ // finally add volume
+ if(validLCDD) {
+ if(_debug)
+ System.out.printf("%s: adding volume %s\n", getClass().getSimpleName(),lcddObj.getName());
+ if(!lcddObj.getVisName().isEmpty()) {
+ if(_debug)
+ System.out.printf("%s: set vis %s for volume %s\n", getClass().getSimpleName(), lcddObj.getVisName(),lcddObj.getName());
+ lcddObj.getVolume().setVisAttributes(lcdd.getVisAttributes(lcddObj.getVisName()));
+ if(_debug)
+ if(lcdd.getVisAttributes(lcddObj.getVisName())!=null) {
+ System.out.printf("%s: found vis %s\n", getClass().getSimpleName(), lcdd.getVisAttributes(lcddObj.getVisName()).getAttributeValue("name"));
+ } else {
+ System.out.printf("%s: vis not found\n", getClass().getSimpleName());
+ }
+ }
+ lcdd.add(lcddObj.getVolume());
+ } else {
+ if(_debug) System.out.printf("%s: don't add volume %s\n", getClass().getSimpleName(),lcddObj.getName());
+ }
+ if(_debug) System.out.printf("%s: DONE adding %s\n", getClass().getSimpleName(),lcddObj.getName());
+ }
+
+
+ /**
+ * Set properties of the physical volume.
+ * @param surveyVolume
+ */
+ private void setPhysicalVolumeProperties(LCDDSurveyVolume surveyVolume, SensitiveDetector sd) throws DataConversionException {
+
+ if(_debug) System.out.printf("%s: setPhysVolumeProperties for name %s\n", getClass().getSimpleName(),surveyVolume.getName());
+
+ String name = surveyVolume.getName();
+ if(HPSTrackerBuilder.isHalfModule(surveyVolume.getName())) {
+ setHalfModulePhysicalVolumeProperties(surveyVolume);
+ }
+ else if(HPSTrackerBuilder.isActiveSensor(surveyVolume.getName())) {
+ setActiveSensorPhysicalVolumeProperties(surveyVolume, sd);
+ }
+ else if(HPSTrackerBuilder.isSensor(surveyVolume.getName())) {
+ setSensorPhysicalVolumeProperties(surveyVolume);
+ }
+ else if(name.endsWith("lamination")) {
+ surveyVolume.getPhysVolume().addPhysVolID("component", 2);
+ }
+ else if(name.endsWith("cf")) {
+ surveyVolume.getPhysVolume().addPhysVolID("component", 1);
+ }
+ else if(name.endsWith("hybrid")) {
+ surveyVolume.getPhysVolume().addPhysVolID("component", 3);
+ }
+
+ if(_debug) {
+ System.out.printf("%s: %d physvolid's\n", getClass().getSimpleName(),surveyVolume.getPhysVolume().getChildren("physvolid").size());
+ //geomObj.getPhysVolume().getChildren("physvolid field_name="sensor" value="0"")
+ for (Iterator i = surveyVolume.getPhysVolume().getChildren("physvolid").iterator(); i.hasNext();) {
+ Element e = (Element)i.next();
+ System.out.printf("%s: %s %d\n", getClass().getSimpleName(),e.getAttributeValue("field_name"),e.getAttribute("value").getIntValue());
+ }
+
+ if(_debug) System.out.printf("%s: DONE setPhysVolumeProperties for name %s\n", getClass().getSimpleName(),surveyVolume.getName());
+
+ }
+
+
+ }
+
+ private void setSensorPhysicalVolumeProperties(LCDDSurveyVolume surveyVolume) {
+ surveyVolume.getPhysVolume().addPhysVolID("component", 0);
+ }
+
+
+ private void setActiveSensorPhysicalVolumeProperties(LCDDSurveyVolume surveyVolume, SensitiveDetector sd) {
+ surveyVolume.getPhysVolume().addPhysVolID("sensor", 0);
+ surveyVolume.getVolume().setSensitiveDetector(sd);
+ }
+
+ abstract protected int getModuleNumber(String surveyVolume);
+
+
+
+
+ private void setHalfModulePhysicalVolumeProperties(LCDDSurveyVolume surveyVolume) throws DataConversionException {
+ PhysVol physVol = surveyVolume.getPhysVolume();
+ int sysId = node.getAttribute("id").getIntValue();
+
+ //use the old definition of layer number to be consistent
+ int layer = builder._builder.getOldGeomDefLayerFromVolumeName(surveyVolume.getName());
+ if(_debug) System.out.printf("%s: physVolId layer = %d (compare with new layer %d)\n", getClass().getSimpleName(),layer, HPSTrackerBuilder.getLayerFromVolumeName(surveyVolume.getName()));
+
+ //Find the module number
+ int moduleNumber = getModuleNumber(surveyVolume.getName());
+
+ physVol.addPhysVolID("system", sysId);
+ physVol.addPhysVolID("barrel", 0);
+ surveyVolume.getPhysVolume().addPhysVolID("layer", layer);
+ surveyVolume.getPhysVolume().addPhysVolID("module", moduleNumber);
+
+
+ }
+
+
+ protected void makeBeamPlane(Volume motherVolume, LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+ Hep3Vector ball_pos_beamplane = new BasicHep3Vector(-1.0*beamPlaneWidth/2.0,0.0,beamPlaneLength/2.0);
+ Hep3Vector vee_pos_beamplane = new BasicHep3Vector(ball_pos_beamplane.x()+beamPlaneWidth,ball_pos_beamplane.y(),ball_pos_beamplane.z());
+ Hep3Vector flat_pos_beamplane = new BasicHep3Vector(ball_pos_beamplane.x(), ball_pos_beamplane.y(), ball_pos_beamplane.z()-beamPlaneLength/2.0);
+ makeBeamPlane(motherVolume, ball_pos_beamplane, vee_pos_beamplane, flat_pos_beamplane, lcdd, sens);
+ }
+
+
+
+ protected void makeBeamPlane(Volume motherVolume, Hep3Vector ball_pos_base_plate, Hep3Vector vee_pos_base_plate,Hep3Vector flat_pos_base_plate, LCDD lcdd, SensitiveDetector sens) throws JDOMException {
+
+
+ if(_debug) {
+ System.out.println("--- makeBeamPlane ----");
+
+ }
+
+ // create the coordinate system of the beam plane in the tracking volume
+ // since this is a dummy volume it is based on the position of the base plate coordinate system
+ // width - u
+ // length - v
+ // thickness - w
+ Hep3Vector ball_pos_beamplane = ball_pos_base_plate;
+ Hep3Vector vee_pos_beamplane = vee_pos_base_plate;
+ Hep3Vector flat_pos_beamplane = flat_pos_base_plate;
+ SurveyCoordinateSystem beamplane_coord = new SurveyCoordinateSystem(ball_pos_beamplane, vee_pos_beamplane, flat_pos_beamplane);
+ Transform3D trans_beamplane_to_tracking = beamplane_coord.getTransformation();
+
+ String volName = "beamPlaneVol";
+ //Box box = new Box(volName + "Box", HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_width, HPSTestRunTracker2014GeometryDefinition.TrackerEnvelope.base_length*2, beamPlaneThickness);
+ Box box = new Box(volName + "Box", beamPlaneWidth, beamPlaneLength*2, beamPlaneThickness);
+ lcdd.add(box);
+ Volume volume = new Volume(volName + "_volume", box, lcdd.getMaterial("Vacuum"));
+
+
+ if(_debug) {
+ System.out.println(String.format("ball_pos_beamplane %s", ball_pos_beamplane.toString()));
+ System.out.println(String.format("vee_pos_beamplane %s", vee_pos_beamplane.toString()));
+ System.out.println(String.format("flat_pos_beamplane %s", flat_pos_beamplane.toString()));
+ System.out.println(String.format("beamplane_coord:\n%s", beamplane_coord.toString()));
+ }
+
+
+ // Find distance to center in the local coordinate system
+ Hep3Vector box_center_base_local = new BasicHep3Vector(beamPlaneWidth/2.0, beamPlaneLength/2.0, beamPlaneThickness/2.0);
+
+ //translate to the mother coordinate system
+ Hep3Vector box_center_base = trans_beamplane_to_tracking.transformed(box_center_base_local);
+
+ if(_debug) {
+ System.out.println(String.format("box_center_base_local %s", box_center_base_local.toString()));
+ System.out.println(String.format("box_center_base %s", box_center_base.toString()));
+ }
+
+ // Create the LCDD position
+ Position pos = new Position(volName + "_position",box_center_base.x(), box_center_base.y(), box_center_base.z());
+
+ //Find LCDD Euler rotation angles from coordinate system unit vectors
+ Hep3Vector lcdd_rot_angles = TransformationUtils.getCardanAngles(beamplane_coord.v(), beamplane_coord.w(), new BasicHep3Vector(0,1,0),new BasicHep3Vector(0,0,1));
+ Rotation rot = new Rotation(volName + "_rotation",lcdd_rot_angles.x(), lcdd_rot_angles.y(), lcdd_rot_angles.z());
+ lcdd.add(pos);
+ lcdd.add(rot);
+
+ // Create the physical volume
+ PhysVol basePV = new PhysVol(volume, motherVolume, pos, rot);
+ if(_debug) {
+ System.out.println("Created physical vomume " + basePV.getName());
+ }
+
+ volume.setVisAttributes(lcdd.getVisAttributes("BeamPlaneVis"));
+
+ lcdd.add(volume);
+
+ }
+
+
+
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1.java Tue May 5 14:05:24 2015
@@ -0,0 +1,26 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.geometry.compact.converter.HPSTracker2014v1LCDDBuilder;
+import org.lcsim.geometry.compact.converter.HPSTrackerLCDDBuilder;
+import org.lcsim.geometry.compact.converter.lcdd.util.LCDD;
+import org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector;
+
+public class HPSTracker2014v1 extends HPSTracker2014
+{
+ public HPSTracker2014v1(Element node) throws JDOMException
+ {
+ super(node);
+ }
+
+ /* (non-Javadoc)
+ * @see org.lcsim.geometry.compact.converter.lcdd.HPSTracker2014Base#initializeBuilder(org.lcsim.geometry.compact.converter.lcdd.util.LCDD, org.lcsim.geometry.compact.converter.lcdd.util.SensitiveDetector)
+ */
+ protected HPSTrackerLCDDBuilder initializeBuilder(LCDD lcdd, SensitiveDetector sens) {
+ return new HPSTracker2014v1LCDDBuilder(_debug,node,lcdd,sens);
+ }
+
+
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTestRunTracker2014.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTestRunTracker2014.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTestRunTracker2014.java Tue May 5 14:05:24 2015
@@ -0,0 +1,29 @@
+package org.lcsim.geometry.subdetector;
+
+import hep.graphics.heprep.HepRep;
+import hep.graphics.heprep.HepRepFactory;
+
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.detector.converter.heprep.DetectorElementToHepRepConverter;
+
+public class HPSTestRunTracker2014 extends AbstractTracker {
+
+ public HPSTestRunTracker2014(Element node) throws JDOMException
+ {
+ super(node);
+ }
+
+ public void appendHepRep(HepRepFactory factory, HepRep heprep)
+ {
+ DetectorElementToHepRepConverter.convert(getDetectorElement(), factory, heprep, -1, false, getVisAttributes().getColor());
+ }
+
+ public boolean isEndcap() {
+ return false;
+ }
+
+ public boolean isBarrel() {
+ return true;
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014.java Tue May 5 14:05:24 2015
@@ -0,0 +1,30 @@
+package org.lcsim.geometry.subdetector;
+
+import hep.graphics.heprep.HepRep;
+import hep.graphics.heprep.HepRepFactory;
+
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.detector.converter.heprep.DetectorElementToHepRepConverter;
+
+public class HPSTracker2014 extends AbstractTracker {
+
+ public HPSTracker2014(Element node) throws JDOMException
+ {
+ super(node);
+ }
+
+ public void appendHepRep(HepRepFactory factory, HepRep heprep)
+ {
+ DetectorElementToHepRepConverter.convert(getDetectorElement(), factory, heprep, -1, false, getVisAttributes().getColor());
+ }
+
+ public boolean isEndcap() {
+ return false;
+ }
+
+ public boolean isBarrel() {
+ return true;
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014v1.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014v1.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/main/java/org/lcsim/geometry/subdetector/HPSTracker2014v1.java Tue May 5 14:05:24 2015
@@ -0,0 +1,30 @@
+package org.lcsim.geometry.subdetector;
+
+import hep.graphics.heprep.HepRep;
+import hep.graphics.heprep.HepRepFactory;
+
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.lcsim.detector.converter.heprep.DetectorElementToHepRepConverter;
+
+public class HPSTracker2014v1 extends AbstractTracker {
+
+ public HPSTracker2014v1(Element node) throws JDOMException
+ {
+ super(node);
+ }
+
+ public void appendHepRep(HepRepFactory factory, HepRep heprep)
+ {
+ DetectorElementToHepRepConverter.convert(getDetectorElement(), factory, heprep, -1, false, getVisAttributes().getColor());
+ }
+
+ public boolean isEndcap() {
+ return false;
+ }
+
+ public boolean isBarrel() {
+ return true;
+ }
+
+}
Added: java/branches/HPSJAVA-499/detector-model/src/test/java/org/hps/detector/SvtAlignmentTest.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/test/java/org/hps/detector/SvtAlignmentTest.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/test/java/org/hps/detector/SvtAlignmentTest.java Tue May 5 14:05:24 2015
@@ -0,0 +1,19 @@
+package org.hps.detector;
+
+import junit.framework.TestCase;
+
+import org.hps.conditions.database.DatabaseConditionsManager;
+
+/**
+ * Test loading SVT alignment constants into the Java detector model.
+ *
+ * @author <a href="mailto:[log in to unmask]">Jeremy McCormick</a>
+ */
+public class SvtAlignmentTest extends TestCase {
+
+ public void testSvtAlignment() throws Exception {
+ final DatabaseConditionsManager manager = DatabaseConditionsManager.getInstance();
+ // manager.setDetector("HPS-EngRun2015-1_5mm-v1", 5259);
+ manager.setDetector("HPS-EngRun2015-1_5mm-v1", 0);
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014LCDDTest.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014LCDDTest.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTestRunTracker2014LCDDTest.java Tue May 5 14:05:24 2015
@@ -0,0 +1,35 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.lcsim.util.test.TestUtil.TestOutputFile;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+*
+* @author Per Hansson Adrian <[log in to unmask]>
+*/
+public class HPSTestRunTracker2014LCDDTest extends TestCase
+{
+ public HPSTestRunTracker2014LCDDTest(String name)
+ {
+ super(name);
+ }
+
+ public static TestSuite suite()
+ {
+ return new TestSuite(HPSTestRunTracker2014LCDDTest.class);
+ }
+
+ public void test_converter() throws Exception
+ {
+ InputStream in = HPSTestRunTracker2014.class.getResourceAsStream("/org/lcsim/geometry/subdetector/HPSTestRunTracker2014.xml");
+ OutputStream out = new BufferedOutputStream(new FileOutputStream(new TestOutputFile("HPSTestRunTracker2014.lcdd")));
+ new Main().convert("HPSTestRunTracker2014",in,out);
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014LCDDTest.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014LCDDTest.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014LCDDTest.java Tue May 5 14:05:24 2015
@@ -0,0 +1,35 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.lcsim.util.test.TestUtil.TestOutputFile;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+*
+* @author Per Hansson Adrian <[log in to unmask]>
+*/
+public class HPSTracker2014LCDDTest extends TestCase
+{
+ public HPSTracker2014LCDDTest(String name)
+ {
+ super(name);
+ }
+
+ public static TestSuite suite()
+ {
+ return new TestSuite(HPSTracker2014LCDDTest.class);
+ }
+
+ public void test_converter() throws Exception
+ {
+ InputStream in = HPSTracker2014.class.getResourceAsStream("/org/lcsim/geometry/subdetector/HPSTracker2014.xml");
+ OutputStream out = new BufferedOutputStream(new FileOutputStream(new TestOutputFile("HPSTracker2014.lcdd")));
+ new Main().convert("HPSTracker2014",in,out);
+ }
+}
Added: java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1LCDDTest.java
=============================================================================
--- java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1LCDDTest.java (added)
+++ java/branches/HPSJAVA-499/detector-model/src/test/java/org/lcsim/geometry/compact/converter/lcdd/HPSTracker2014v1LCDDTest.java Tue May 5 14:05:24 2015
@@ -0,0 +1,35 @@
+package org.lcsim.geometry.compact.converter.lcdd;
+
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.lcsim.util.test.TestUtil.TestOutputFile;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+*
+* @author Per Hansson Adrian <[log in to unmask]>
+*/
+public class HPSTracker2014v1LCDDTest extends TestCase
+{
+ public HPSTracker2014v1LCDDTest(String name)
+ {
+ super(name);
+ }
+
+ public static TestSuite suite()
+ {
+ return new TestSuite(HPSTracker2014v1LCDDTest.class);
+ }
+
+ public void test_converter() throws Exception
+ {
+ InputStream in = HPSTracker2014v1.class.getResourceAsStream("/org/lcsim/geometry/subdetector/HPSTracker2014v1.xml");
+ OutputStream out = new BufferedOutputStream(new FileOutputStream(new TestOutputFile("HPSTracker2014v1.lcdd")));
+ new Main().convert("HPSTracker2014v1",in,out);
+ }
+}
|
