diff -N CellReadout2D.hh
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ CellReadout2D.hh	30 May 2013 00:04:12 -0000	1.1
@@ -0,0 +1,133 @@

+#ifndef lcdd_CellReadout2D_hh
+#define lcdd_CellReadout2D_hh 1
+
+#include <vector>
+#include <map>
+
+/**
+ * 2D cell readout with positive coordinate system originating
+ * at the upper left of a box volume.  Cells are numbered from x,y = (1,1).
+ */
+class CellReadout2D
+{
+
+public:
+
+	typedef std::pair<int, int> Cell;
+	typedef std::pair<double, double> PositionXY;
+
+
+    virtual ~CellReadout2D();
+
+    CellReadout2D(double cellSizeX, double cellSizeY);
+
+	/**
+	 * Get the X cell size.
+	 */
+	virtual double getCellSizeX();
+
+	/**
+	 * Get the Y cell size.
+	 */
+	virtual double getCellSizeY();
+
+	/**
+	 * Get the full dimension of the readout in X.
+	 */
+	virtual double getDimensionX();
+
+	/**
+	 * Get the full dimension of the readout in Y.
+	 */
+	virtual double getDimensionY();
+
+	/**
+	 * Get the local position of the cell.
+	 */
+	virtual PositionXY getPosition(Cell);
+
+	/**
+	 * Get the cell from a position.
+	 */
+    virtual Cell getCell(PositionXY);
+
+	/**
+	 * Get the X bin from a position.
+	 */
+	virtual int getCellX(double x);
+
+	/**
+	 * Get Y bin from a position.
+	 */
+	virtual int getCellY(double y);
+
+	/*
+	 * Get the X position from an X bin value.
+	 */
+	virtual double getPositionX(int x);
+
+	/**
+	 * Get the Y position from a Y bin value.
+	 */
+	virtual double getPositionY(int y);
+
+	/**
+	 * Get the neighbors of a cell.
+	 */
+	virtual std::vector<Cell> getNeighbors(Cell);
+
+	/**
+	 * Get a pair of indices representing a cell.  This method should check that the indices are valid.
+	 */
+	virtual Cell createCell(int x, int y);
+
+	/**
+	 * Check if an X index is valid.
+	 */
+	virtual bool isValidX(int x);
+
+	/**
+	 * Check if a Y index is valid.
+	 */
+	virtual bool isValidY(int y);
+
+	/**
+	 * Check if a local X position is inside this readout.
+	 */
+	virtual bool isInsideX(double x);
+
+	/**
+	 * Check if a local Y position is inside this readout.
+	 */
+	virtual bool isInsideY(double y);
+
+	/**
+	 * Given a cell index, return the corresponding coordinate.
+	 */
+	virtual double getCoordinate(int u, double cellSize);
+
+	/**
+	 * Given a coordinate in the readout's reference frame, return the corresponding coordinate.
+	 */
+	virtual int getIndex(double x, double cellSize);
+
+	/**
+	 * Set the X dimension of the readout.
+	 */
+	virtual void setDimensionX(double x);
+
+	/**
+	 * Set the Y dimension of the readout.
+	 */
+	virtual void setDimensionY(double y);
+
+private:
+
+	double m_cellSizeX;
+	double m_cellSizeY;
+
+	double m_dimensionX;
+	double m_dimensionY;
+};
+
+#endif

diff -N CellReadout2DSegmentation.hh
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ CellReadout2DSegmentation.hh	30 May 2013 00:04:12 -0000	1.1
@@ -0,0 +1,40 @@

+#ifndef lcdd_CellReadout2DSegmentation_hh
+#define lcdd_CellReadout2DSegmentation_hh 1
+
+// LCDD
+#include "G4Segmentation.hh"
+#include "CellReadout2D.hh"
+
+// Geant4
+#include "G4ThreeVector.hh"
+
+class G4Step;
+
+/**
+ * Adapt a CellReadout2D to the LCDD Segmentation interface.
+ */
+class CellReadout2DSegmentation : public G4Segmentation
+{
+
+public:
+
+	CellReadout2DSegmentation(double cellSizeX, double cellSizeY);
+
+	virtual ~CellReadout2DSegmentation();
+
+    G4ThreeVector getGlobalHitPos(const G4Step*);
+
+    void setBins(const G4Step*);
+
+    void setBinNames();
+
+    void setup(const G4Step*);
+
+    CellReadout2D::PositionXY localToReadoutCoordinates(G4ThreeVector&);
+
+private:
+
+    CellReadout2D* m_readout;
+};
+
+#endif

diff -N CellReadout2DSegmentationType.hh
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ CellReadout2DSegmentationType.hh	30 May 2013 00:04:12 -0000	1.1
@@ -0,0 +1,58 @@

+// $Header: /cvs/lcd/lcdd/include/CellReadout2DSegmentationType.hh,v 1.1 2013/05/30 00:04:12 jeremy Exp $
+
+#ifndef lcdd_CellReadout2DSegmentationType_hh
+#define lcdd_CellReadout2DSegmentationType_hh 1
+
+#include "SegmentationType.hh"
+
+#include <string>
+
+class CellReadout2DSegmentationType : public SegmentationType
+{
+
+public:
+
+    CellReadout2DSegmentationType() {}
+
+	virtual ~CellReadout2DSegmentationType() {}
+
+public:
+
+	void setCellSizeX(const std::string& cellSizeX)
+	{
+		m_cellSizeX = cellSizeX;
+	}
+
+	void setCellSizeY(const std::string& cellSizeY)
+	{
+		m_cellSizeY = cellSizeY;
+	}
+
+	void setLengthUnit(const std::string& lengthUnit)
+	{
+		m_lengthUnit = lengthUnit;
+	}
+
+	const std::string& getCellSizeX()
+	{
+		return m_cellSizeX;
+	}
+
+	const std::string& getCellSizeY()
+	{
+		return m_cellSizeY;
+	}
+
+	const std::string& getLengthUnit()
+	{
+		return m_lengthUnit;
+	}
+
+protected:
+
+    std::string m_cellSizeX;
+    std::string m_cellSizeY;
+    std::string m_lengthUnit;
+};
+
+#endif

diff -N cell_readout_2d.hh
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ cell_readout_2d.hh	30 May 2013 00:04:12 -0000	1.1
@@ -0,0 +1,31 @@

+// $Header: /cvs/lcd/lcdd/include/cell_readout_2d.hh,v 1.1 2013/05/30 00:04:12 jeremy Exp $
+
+#ifndef lcdd_cell_readout_2d_hh
+#define lcdd_cell_readout_2d_hh 1
+
+// LCDD
+#include "CellReadout2DSegmentationType.hh"
+
+// GDML
+#include "Saxana/SAXObject.h"
+
+class cell_readout_2d: public SAXObject, public CellReadout2DSegmentationType
+{
+
+public:
+
+    cell_readout_2d()
+    {
+    }
+
+    virtual ~cell_readout_2d()
+    {
+    }
+
+    virtual SAXObject::Type type()
+    {
+        return SAXObject::element;
+    }
+};
+
+#endif

diff -u -r1.17 -r1.18
--- G4Segmentation.hh	30 Oct 2009 23:16:59 -0000	1.17
+++ G4Segmentation.hh	30 May 2013 00:04:12 -0000	1.18
@@ -12,131 +12,135 @@

 /**
  * @class G4Segmentation
  * @brief Segmentation base class.

+ * @todo Add method setVolume(G4LogicalVolume*) for setting up segmentation with current step volume.

  */
 class G4Segmentation
 {

-    public:
-        enum EType { eProjective=1, eNonprojective };
-        typedef std::vector<std::string> BinNames;
-
-    public:
-        G4Segmentation(EType segType, int nbins = 2);
-        virtual ~G4Segmentation();
-
-    public:
-
-        /**
-         * Compute the global hit position from a step.
-         */
-        virtual G4ThreeVector getGlobalHitPos(const G4Step* aStep);
-
-        /**
-         * Set the identifier bin values from a step.
-         */
-        virtual void setBins(const G4Step*) = 0;
-
-        /**
-         * Add valid bin names to this segmentation.
-         */
-        virtual void setBinNames() = 0;        
-
-        /**
-         * Compute the bin given a coordinate in one dimension.
-         */
-        static int computeBin(double localDim, double gridDim)
-        {
-            return int(floor(localDim / gridDim ) );

+public:
+    enum EType
+    {
+        eProjective = 1, eNonprojective
+    };
+    typedef std::vector<std::string> BinNames;

-        }

+public:
+    G4Segmentation(EType segType, int nbins = 2);
+    virtual ~G4Segmentation();

-        /**
-         * Compute the coordinate in one dimension given a bin value.
-         */
-        static double computeDim(const int &bin, const double &incr)
-        {
-            return (double(bin) + .5) * incr;
-        }

+public:

-        // DEPRECATED
-        // Used by G4OpticalCalorimeter only.
-        virtual G4ThreeVector getGlobalHitPosPreStep(const G4StepPoint* aPreStepPoint);
-
-        // DEPRECATED
-        // Used by G4OpticalCalorimeter only.
-        G4ThreeVector getLocalHitPos(const G4ThreeVector& localStepPos);
-
-        void resetBins();
-
-        EType getType();
-
-        inline const G4String& getTypeString()
-        {
-            static G4String typestr;
-            if ( m_type == eProjective ) {
-                typestr = "Projective";
-            }
-            else if ( m_type == eNonprojective ) {
-                typestr = "Nonprojective";
-            }
-            else {
-                typestr = "Unknown";
-            }

+    /**
+     * Compute the global hit position from a step.
+     */
+    virtual G4ThreeVector getGlobalHitPos(const G4Step* aStep);

-            return typestr;
-        }

+    /**
+     * Set the identifier bin values from a step.
+     */
+    virtual void setBins(const G4Step*) = 0;

-        inline int getBin(int idx)
-        {
-            return m_bins.at( idx );
-        }

+    /**
+     * Add valid bin names to this segmentation.
+     */
+    virtual void setBinNames() = 0;

-        inline const std::string& getBinName(int idx)
-        {
-            return m_binNames.at(idx);
-        }

+    /**
+     * Compute the bin given a coordinate in one dimension.
+     */
+    static int computeBin(double localDim, double gridDim)
+    {
+        return int(floor(localDim / gridDim));

-        inline void addBinName(const std::string& binName)
-        {
-            m_binNames.push_back(binName);
-        }

+    }

-        void setBin(int binIdx, int binVal);

+    /**
+     * Compute the coordinate in one dimension given a bin value.
+     */
+    static double computeDim(const int &bin, const double &incr)
+    {
+        return (double(bin) + .5) * incr;
+    }

-        int getNumberOfBins();

+    // DEPRECATED
+    // Used by G4OpticalCalorimeter only.
+    virtual G4ThreeVector getGlobalHitPosPreStep(const G4StepPoint* aPreStepPoint);

-        const std::vector<int>& getBins();

+    // DEPRECATED
+    // Used by G4OpticalCalorimeter only.
+    G4ThreeVector getLocalHitPos(const G4ThreeVector& localStepPos);

-        const std::vector<std::string>& getBinNames() 
-        {
-            return m_binNames;
-        }

+    void resetBins();
+
+    EType getType();

-        // Print the bins.
-        void printOutBins(std::ostream& os)
-        {
-            printOutBins( os, m_bins );

+    inline const G4String& getTypeString()
+    {
+        static G4String typestr;
+        if (m_type == eProjective) {
+            typestr = "Projective";
+        }
+        else if (m_type == eNonprojective) {
+            typestr = "Nonprojective";
+        }
+        else {
+            typestr = "Unknown";

         }
 

-        static void printOutBins(std::ostream& os, const std::vector<int>& bins);

+        return typestr;
+    }
+
+    inline int getBin(int idx)
+    {
+        return m_bins.at(idx);
+    }
+
+    inline const std::string& getBinName(int idx)
+    {
+        return m_binNames.at(idx);
+    }
+
+    inline void addBinName(const std::string& binName)
+    {
+        m_binNames.push_back(binName);
+    }
+
+    void setBin(int binIdx, int binVal);
+
+    int getNumberOfBins();
+
+    const std::vector<int>& getBins();
+
+    const std::vector<std::string>& getBinNames()
+    {
+        return m_binNames;
+    }
+
+    // Print the bins.
+    void printOutBins(std::ostream& os)
+    {
+        printOutBins(os, m_bins);
+    }
+
+    static void printOutBins(std::ostream& os, const std::vector<int>& bins);

-        /*
-         * Check whether the solid is valid for this segmentation.
-         */
-        virtual bool isValidSolid(G4VSolid*);

+    /*
+     * Check whether the solid is valid for this segmentation.
+     */
+    virtual bool isValidSolid(G4VSolid*);

-    private:

+private:

-        // bin values
-        std::vector<int> m_bins;

+    // bin values
+    std::vector<int> m_bins;

-        // bin names
-        BinNames m_binNames;

+    // bin names
+    BinNames m_binNames;

-        // number of numbers
-        int m_numBins;

+    // number of numbers
+    int m_numBins;

-        // type of segmentation
-        EType m_type;

+    // type of segmentation
+    EType m_type;

 };
 
 #endif

diff -u -r1.18 -r1.19
--- ReadoutUtil.hh	1 Apr 2008 19:53:02 -0000	1.18
+++ ReadoutUtil.hh	30 May 2013 00:04:12 -0000	1.19
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/lcdd/include/ReadoutUtil.hh,v 1.18 2008/04/01 19:53:02 wenzel Exp $

+// $Header: /cvs/lcd/lcdd/include/ReadoutUtil.hh,v 1.19 2013/05/30 00:04:12 jeremy Exp $

 #ifndef LCDD_READOUTUTIL_HH
 #define LCDD_READOUTUTIL_HH 1
 

@@ -34,13 +34,11 @@

 
 public:
 

-  static G4ThreeVector computeThreeVectorMean(const G4ThreeVector& vec1,
-					      const G4ThreeVector& vec2);

+  static G4ThreeVector computeThreeVectorMean(const G4ThreeVector& vec1, const G4ThreeVector& vec2);

 
   static G4ThreeVector computeMidPos(const G4Step* aStep);
 

-  static G4double computeDistance(const G4ThreeVector& vec1,
-				  const G4ThreeVector& vec2);

+  static G4double computeDistance(const G4ThreeVector& vec1, const G4ThreeVector& vec2);

 
   static G4double computeDistance(const G4Step* aStep);
 

@@ -49,8 +47,7 @@

   static G4TouchableHandle getTouchableFromStep(const G4Step* aStep);
 
 

-  static G4ThreeVector getVolumeGlobalPosition(const G4StepPoint* aStepPoint,
-					       const G4ThreeVector& pnt );

+  static G4ThreeVector getVolumeGlobalPosition(const G4StepPoint* aStepPoint, const G4ThreeVector& pnt );

 
   static G4ThreeVector getVolumeGlobalPosition(const G4StepPoint* aStepPoint);
 

@@ -64,14 +61,10 @@

   
   static double getTubsThickness(const G4Tubs* tubs);
 

-  static G4ThreeVector transformLocalToGlobal(const G4Step* aStep,
-					      const G4ThreeVector& localPos);
-  static G4ThreeVector transformLocalToGlobal(const G4StepPoint* aPreStepPoint,
-					      const G4ThreeVector& localPos);
-  static G4ThreeVector transformGlobalToLocal(const G4Step* aStep,
-					      const G4ThreeVector& globalPos); 
-  static G4ThreeVector transformGlobalToLocal(const G4StepPoint* aPreStepPoint,
-					      const G4ThreeVector& globalPos); 

+  static G4ThreeVector transformLocalToGlobal(const G4Step* aStep, const G4ThreeVector& localPos);
+  static G4ThreeVector transformLocalToGlobal(const G4StepPoint* aPreStepPoint, const G4ThreeVector& localPos);
+  static G4ThreeVector transformGlobalToLocal(const G4Step* aStep, const G4ThreeVector& globalPos);
+  static G4ThreeVector transformGlobalToLocal(const G4StepPoint* aPreStepPoint, const G4ThreeVector& globalPos);

   
   static int getVolumeNumber(G4TouchableHandle theTouchable, int historyDepth = -1);
 

diff -u -r1.7 -r1.8
--- lcdd_sensitive_detectors.xsd	7 Dec 2010 01:03:13 -0000	1.7
+++ lcdd_sensitive_detectors.xsd	30 May 2013 00:04:12 -0000	1.8
@@ -224,7 +224,30 @@

             </xs:extension>
         </xs:complexContent>
     </xs:complexType>

-

+    
+    <xs:complexType name="CellReadout2DSegmentationType">
+        <xs:annotation>
+            <xs:documentation>
+                CellReadout2D segmentation type.
+            </xs:documentation>
+        </xs:annotation>
+        <xs:complexContent>
+            <xs:extension base="SegmentationType">
+                <xs:attribute name="cell_size_x" type="xs:double" use="required"/>
+                <xs:attribute name="cell_size_y" type="xs:double" use="required"/>
+                <xs:attribute default="mm"  name="lunit"  type="xs:string"/>
+            </xs:extension>
+        </xs:complexContent>
+    </xs:complexType>
+    
+    <xs:element name="cell_readout_2d" substitutionGroup="segmentation" type="CellReadout2DSegmentationType">
+        <xs:annotation>
+            <xs:documentation>
+                The element definition for the CellReadout2DSegmentationType.
+            </xs:documentation>
+        </xs:annotation>
+    </xs:element>
+    

     <xs:element name="grid_xyz" substitutionGroup="segmentation" type="NonprojectiveSegmentationType">
         <xs:annotation>
             <xs:documentation>

diff -N cell_readout_2dProcess.cc
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ cell_readout_2dProcess.cc	30 May 2013 00:04:12 -0000	1.1
@@ -0,0 +1,77 @@

+// $Header: /cvs/lcd/lcdd/src/cell_readout_2dProcess.cc,v 1.1 2013/05/30 00:04:12 jeremy Exp $
+
+// GDML
+#include "Saxana/ProcessingConfigurator.h"
+#include "Saxana/ProcessingContext.h"
+#include "Saxana/SAXProcessor.h"
+#include "Saxana/StateStack.h"
+#include "Saxana/SAXProcessingState.h"
+#include "Saxana/SAXStateProcess.h"
+#include "Saxana/SAXComponentFactory.h"
+
+// LCDD
+#include "cell_readout_2d.hh"
+
+// std
+#include <iostream>
+
+class cell_readout_2dProcess: public SAXStateProcess
+{
+
+public:
+
+    cell_readout_2dProcess(const ProcessingContext* context = 0)
+        : SAXStateProcess(context), m_obj(0)
+    {
+    }
+
+    virtual ~cell_readout_2dProcess()
+    {
+    }
+
+    virtual const SAXComponentObject* Build() const
+    {
+        return this;
+    }
+
+    virtual void StartElement(const std::string& name, const ASCIIAttributeList& attrs)
+    {
+        std::cout << "cell_readout_2dProcess::StartElement: " << name << std::endl;
+
+        SAXObject** obj = Context()->GetTopObject();
+
+        cell_readout_2d* np = new cell_readout_2d;
+
+        np->setLengthUnit(attrs.getValue("lunit"));
+
+        np->setCellSizeX(attrs.getValue("cell_size_x"));
+        np->setCellSizeY(attrs.getValue("cell_size_y"));
+
+        m_obj = np;
+        *obj = np;
+    }
+
+    virtual void EndElement(const std::string&)
+    {
+    }
+
+    virtual void Characters(const std::string&)
+    {
+    }
+
+    virtual void StackPopNotify(const std::string&)
+    {
+    }
+
+    virtual const std::string& State() const
+    {
+        static std::string tag = "cell_readout_2d";
+        return tag;
+    }
+
+private:
+
+    SAXObject* m_obj;
+};
+
+DECLARE_PROCESS_FACTORY(cell_readout_2dProcess)

diff -u -r1.39 -r1.40
--- G4CalorimeterSD.cc	23 Aug 2011 22:40:52 -0000	1.39
+++ G4CalorimeterSD.cc	30 May 2013 00:04:12 -0000	1.40
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/lcdd/src/G4CalorimeterSD.cc,v 1.39 2011/08/23 22:40:52 jeremy Exp $

+// $Header: /cvs/lcd/lcdd/src/G4CalorimeterSD.cc,v 1.40 2013/05/30 00:04:12 jeremy Exp $

 #include "G4CalorimeterSD.hh"
 
 // lcdd

@@ -128,8 +128,7 @@

     
     // This needs to be a <= comparison for cutting on 0,
     // Geantinos, which always have 0 edep, are allowed.

-    if (theEdep <= getEcut() && !isGeantino()) 
-    {

+    if (theEdep <= getEcut() && !isGeantino()) {

 #ifdef G4VERBOSE
         if (getVerbose() > 2) {
             std::cout << "G4CalorimeterSD::ProcessHits - cut on edep " << theEdep << std::endl;

@@ -165,12 +164,10 @@

     G4CalorimeterHit* fndHit  = 0;
     
     // hit is not found?

-    if (!( fndHit = findHit(thisHit))) 
-    {

+    if (!( fndHit = findHit(thisHit))) {

         
 #ifdef G4VERBOSE

-        if (getVerbose() > 1)
-        {

+        if (getVerbose() > 1) {

             std::cout << "G4CalorimeterSD::ProcessHits - new hit" << std::endl;
         }
 #endif

diff -u -r1.9 -r1.10
--- G4SegmentationFactory.cc	1 Feb 2012 10:28:56 -0000	1.9
+++ G4SegmentationFactory.cc	30 May 2013 00:04:12 -0000	1.10
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/lcdd/src/G4SegmentationFactory.cc,v 1.9 2012/02/01 10:28:56 jeremy Exp $

+// $Header: /cvs/lcd/lcdd/src/G4SegmentationFactory.cc,v 1.10 2013/05/30 00:04:12 jeremy Exp $

 
 // GDML
 #include "Saxana/SAXObject.h"

@@ -14,6 +14,7 @@

 #include "nonprojective_cylinder.hh"
 #include "projective_cylinder.hh"
 #include "projective_zplane.hh"

+#include "cell_readout_2d.hh"

 
 // LCDD G4 segmentation bindings
 #include "G4Segmentation.hh"

@@ -22,98 +23,85 @@

 #include "G4ProjectiveCylinderSegmentation.hh"
 #include "G4ProjectiveZPlaneSegmentation.hh"
 #include "G4NonprojectiveCylinderSegmentation.hh"

+#include "CellReadout2DSegmentation.hh"

 
 #include <iostream>
 
 G4Segmentation* G4SegmentationFactory::createSegmentation(SAXObject* obj, const std::string& tag)
 {

+    //std::cout << "creating segmentation" << std::endl;
+

     G4Segmentation* seg = 0;
     GDMLExpressionEvaluator* calc = GDMLProcessor::GetInstance()->GetEvaluator();
 

-    if ( tag == "projective_cylinder" ) 
-    {
-        //std::cout << "add projective_cylinder here" << std::endl;
-
-        projective_cylinder* prj = dynamic_cast<projective_cylinder*> ( obj  );
-

+    if (tag == "projective_cylinder") {
+        projective_cylinder* prj = dynamic_cast<projective_cylinder*>(obj);

         if (prj) {
             int ntheta, nphi;
             std::string sval = prj->get_ntheta();

-            ntheta = (int)calc->Eval( sval );

+            ntheta = (int) calc->Eval(sval);

             sval = prj->get_nphi();

-            nphi = (int)calc->Eval( sval );
-

+            nphi = (int) calc->Eval(sval);

             seg = new G4ProjectiveCylinderSegmentation(ntheta, nphi);

-        } 
-        else 
-        {

+        } else {

             std::cerr << "Failed cast to projective_cylinder!" << std::endl;
         }

-    } 
-    // GridXYZ
-    else if ( tag == "grid_xyz" ) 
-    {
-        grid_xyz* np = dynamic_cast<grid_xyz*> ( obj );
-        if (np) 
-        {

+
+    } else if (tag == "grid_xyz") {
+        // GridXYZ
+        grid_xyz* np = dynamic_cast<grid_xyz*>(obj);
+        if (np) {

             double gsx, gsy, gsz;
             gsx = gsy = gsz = 0.;
             std::string lunit = np->get_lunit();
 
             std::string sval = np->get_gridSizeX();
             sval += "*" + lunit;

-            gsx = calc->Eval( sval );

+            gsx = calc->Eval(sval);

 
             sval = np->get_gridSizeY();
             sval += "*" + lunit;

-            gsy = calc->Eval( sval );

+            gsy = calc->Eval(sval);

 
             sval = np->get_gridSizeZ();
             sval += "*" + lunit;

-            gsz = calc->Eval( sval );	    

+            gsz = calc->Eval(sval);

 
             //std::cout << "grid x, y, z: " << gsx << ", " << gsy << ", " << gsz << std::endl;
 
             seg = new G4GridXYZSegmentation(gsx,

-                                            gsy,
-                                            gsz);
-        }
-        else 
-        {

+                    gsy,
+                    gsz);
+        } else {

             std::cerr << "Failed cast to grid_xyz!" << std::endl;
         }

-    } 

+    }

     // GlobalGridXY

-    else if ( tag == "global_grid_xy" )
-    {
-        global_grid_xy* gridxy = dynamic_cast<global_grid_xy*> ( obj );
-        if (gridxy) 
-        {        

+    else if (tag == "global_grid_xy") {
+        global_grid_xy* gridxy = dynamic_cast<global_grid_xy*>(obj);
+        if (gridxy) {

             double gsx, gsy;
             gsx = gsy = 0.;
             std::string lunit = gridxy->get_lunit();
 
             std::string sval = gridxy->get_gridSizeX();
             sval += "*" + lunit;

-            gsx = calc->Eval( sval );

+            gsx = calc->Eval(sval);

 
             sval = gridxy->get_gridSizeY();
             sval += "*" + lunit;

-            gsy = calc->Eval( sval );

+            gsy = calc->Eval(sval);

 
             seg = new G4GlobalGridXYSegmentation(gsx, gsy);

-        } 
-        else 
-        {

+        } else {

             std::cerr << "Failed cast to global_grid_xy!" << std::endl;

-        } 
-    }
-    // handle NP cylinder
-    else if ( tag == "nonprojective_cylinder" ) {
-      

+        }
+    } else if (tag == "nonprojective_cylinder") {
+        // handle NP cylinder
+

         //std::cout << "add nonprojective_cylinder here" << std::endl;
 

-        nonprojective_cylinder* np = dynamic_cast<nonprojective_cylinder*> ( obj );

+        nonprojective_cylinder* np = dynamic_cast<nonprojective_cylinder*>(obj);

         if (np) {
 
             double gsp = 0;

@@ -123,53 +111,67 @@

 
             std::string sval = np->get_gridSizePhi();
             sval += "*" + lunit;

-            gsp = calc->Eval( sval );

+            gsp = calc->Eval(sval);

 
             sval = np->get_gridSizeZ();
             sval += "*" + lunit;

-            gsz = calc->Eval( sval );

+            gsz = calc->Eval(sval);

-            seg = new G4NonprojectiveCylinderSegmentation( gsp, gsz );
-        }
-        else {

+            seg = new G4NonprojectiveCylinderSegmentation(gsp, gsz);
+        } else {

             std::cerr << "Failed cast to nonprojective_cylinder!" << std::endl;
         }

-    }
-    // handle projective_zplane
-    else if ( tag == "projective_zplane" ) 
-    {
-	    

+    } else if (tag == "projective_zplane") {
+        // handle projective_zplane
+

         //std::cout << "add projective_zplane here" << std::endl;

-	    
-        projective_zplane* prj = dynamic_cast<projective_zplane*> ( obj  );
-	    
-        if ( prj ) {
-	      

+
+        projective_zplane* prj = dynamic_cast<projective_zplane*>(obj);
+
+        if (prj) {
+

             int ntheta, nphi;
             std::string sval = prj->get_ntheta();

-            ntheta = (int)calc->Eval( sval );

+            ntheta = (int) calc->Eval(sval);

             sval = prj->get_nphi();

-            nphi = (int)calc->Eval( sval );
-	      

+            nphi = (int) calc->Eval(sval);
+

             //std::cout << "ntheta, nphi : " 
             //		<< ntheta << ", " 
             //		<< nphi << std::endl;

-	      

+

             seg = new G4ProjectiveZPlaneSegmentation(ntheta, nphi);

-        } // prj exists
-        else 
-        {

+        } else {

             std::cerr << "Failed cast to projective_zplane!" << std::endl;
         } // prj no exist

-    } // projective_zplane
-    // bad segmentation tag
-    else 
-    {

+    } else if (tag == "cell_readout_2d") {
+
+        //std::cout << "building cell_readout_2d" << std::endl;
+
+        cell_readout_2d* elem = dynamic_cast<cell_readout_2d*>(obj);
+        if (0 != elem) {
+            double cellSizeX, cellSizeY;
+            cellSizeX = cellSizeY = 0;
+            std::string lengthUnit = elem->getLengthUnit();
+
+            std::string val = elem->getCellSizeX();
+            val += "*" + lengthUnit;
+            cellSizeX = calc->Eval(val);
+
+            val = elem->getCellSizeY();
+            val += "*" + lengthUnit;
+            cellSizeY = calc->Eval(val);
+
+            std::cout << "G4SegmentationFactory creating CellReadout2DSegmentation(x,y): " << cellSizeX << " " << cellSizeY << std::endl;
+
+            seg = new CellReadout2DSegmentation(cellSizeX, cellSizeY);
+        }
+    } else {
+        // bad segmentation tag

         std::cerr << "Unknown child tag for calorimeter: " << tag << "." << std::endl;
     }
 

-    if (seg == 0)
-    {

+    if (seg == 0) {

         G4Exception("", "", FatalException, "Failed to create segmentation.");
     }
 

diff -u -r1.16 -r1.17
--- G4SensitiveDetector.cc	12 May 2008 21:13:01 -0000	1.16
+++ G4SensitiveDetector.cc	30 May 2013 00:04:12 -0000	1.17
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/lcdd/src/G4SensitiveDetector.cc,v 1.16 2008/05/12 21:13:01 jeremy Exp $

+// $Header: /cvs/lcd/lcdd/src/G4SensitiveDetector.cc,v 1.17 2013/05/30 00:04:12 jeremy Exp $

 
 #include "G4SensitiveDetector.hh"
 

@@ -28,181 +28,190 @@

 const std::string& G4SensitiveDetector::noneStr = "none";
 
 G4SensitiveDetector::G4SensitiveDetector(G4String sdName,

-                                         G4String hcName,
-                                         EType sdType)
-    : G4VSensitiveDetector(sdName),
-      m_idspec(0),
-      m_type(sdType)

+        G4String hcName,
+        EType sdType)
+:
+        G4VSensitiveDetector(sdName),
+                m_idspec(0),
+                m_type(sdType)

 {
     // insert hits collection name into SD's name vector
     collectionName.insert(hcName);

-    

+

     // register detector with G4SDManager
     G4SDManager::GetSDMpointer()->AddNewDetector(this);

-    

+

     // Create the command messenger.
     m_messenger = new SensitiveDetectorMessenger(this);

-    

+

     // Only one HC 
     m_hcids.clear();
     m_hcids.push_back(-1);
 }
 
 G4SensitiveDetector::G4SensitiveDetector(G4String sdName,

-					 const vector<G4String>& hcNames,
-					 EType sdType)
-    : G4VSensitiveDetector(sdName),
-      m_idspec(0),
-      m_type(sdType)

+        const vector<G4String>& hcNames,
+        EType sdType)
+:
+        G4VSensitiveDetector(sdName),
+                m_idspec(0),
+                m_type(sdType)

 {
     m_hcids.clear();

-    
-    for (int i=0; i < (int)hcNames.size(); i++)
-    {

+
+    for (int i = 0; i < (int) hcNames.size(); i++) {

         // insert hits collection name into SD's name vector
         collectionName.insert(hcNames[i]);
         m_hcids.push_back(-1);
     }

-    

+

     // register detector with G4SDManager 
     G4SDManager::GetSDMpointer()->AddNewDetector(this);

-    

+

     // Create the command messenger.
     m_messenger = new SensitiveDetectorMessenger(this);
 }
 
 G4SensitiveDetector::~G4SensitiveDetector()

-{}

+{
+}
+
+void G4SensitiveDetector::Initialize(G4HCofThisEvent *)
+{
+    // no-op
+}
+
+void G4SensitiveDetector::EndOfEvent(G4HCofThisEvent *)
+{
+    // no-op
+}
+
+G4bool G4SensitiveDetector::ProcessHits(G4Step* aStep, G4TouchableHistory*)
+{
+    // set cached step
+    setStep(aStep);
+
+    // doesn't write a hit
+    return false;
+}
+
+const std::string& G4SensitiveDetector::getTypeString() const
+{
+    if (m_type == eTracker) {
+        return trackerStr;
+    }
+    else if (m_type == eCalorimeter) {
+        return calorimeterStr;
+    }
+    return noneStr;
+}
+
+std::ostream& G4SensitiveDetector::printBasicInfo(std::ostream& os)
+{
+    os << "name: " << GetName() << std::endl;
+    os << "type: " << m_type << std::endl;
+    os << "hits collection: " << this->getHCName() << std::endl;
+    os << "hits collection ID: " << m_hcids[0] << std::endl;
+    os << "energy cut: " << G4BestUnit(m_ecut, "Energy") << std::endl;
+    os << "endcap flag: " << m_endcap << std::endl;
+    os << "verbose level: " << m_verbose << std::endl;
+
+    if (m_idspec != 0) {
+        os << "id spec: " << m_idspec->getName() << std::endl;
+        os << "id fields:";
+        for (IdSpec::IdFields::const_iterator it = m_idspec->IdFieldsBegin();
+                it != m_idspec->IdFieldsEnd();
+                it++) {
+            os << " " << (*it)->getLabel();
+        }
+        os << std::endl;
+    } else {
+        os << "idspec points to null!" << std::endl;
+    }

-void G4SensitiveDetector::Initialize(G4HCofThisEvent *) 

+    return os;
+}
+
+Id64bit G4SensitiveDetector::makeId() const

 {

-  // no-op

+    std::cout << "makeId" << std::endl;
+
+    Id64bit id64;
+
+    if (hasIdSpec()) {
+
+        std::cout << "creating ordered id vec" << std::endl;
+
+        // get idvec ordered by this idspec
+        const IdVec ids = IdFactory::createOrderedIdVec(step(), this);
+
+        std::cout << "creating id 64 bit" << std::endl;
+
+        // pack into 64 bit cell id
+        id64 = IdFactory::createId64bit(ids, getIdSpec());
+    }
+
+    std::cout << "returning id" << std::endl;
+
+    return id64;

 }
 

-void G4SensitiveDetector::EndOfEvent(G4HCofThisEvent *) 

+G4VHitsCollection* G4SensitiveDetector::getHitsCollection() const

 {

-  // no-op
-}
-                
-G4bool G4SensitiveDetector::ProcessHits(G4Step* aStep, G4TouchableHistory*) 
-{
-  // set cached step
-  setStep(aStep);
-  
-  // doesn't write a hit
-  return false;
-}
-                
-const std::string& G4SensitiveDetector::getTypeString() const 
-{
-  if ( m_type == eTracker ) {
-    return trackerStr;
-  }
-  else if ( m_type == eCalorimeter ) {
-    return calorimeterStr;
-  }
-  return noneStr;
-}
-                
-std::ostream& G4SensitiveDetector::printBasicInfo(std::ostream& os) 
-{
-  os << "name: " << GetName() << std::endl;
-  os << "type: " << m_type << std::endl;
-  os << "hits collection: " << this->getHCName() << std::endl;
-  os << "hits collection ID: " << m_hcids[0]<< std::endl;
-  os << "energy cut: " << G4BestUnit( m_ecut, "Energy" ) << std::endl;
-  os << "endcap flag: " << m_endcap << std::endl;
-  os << "verbose level: " << m_verbose << std::endl;
-                    
-  if ( m_idspec != 0 ) 
-  {
-      os << "id spec: " << m_idspec->getName() << std::endl;
-      os << "id fields:";
-      for ( IdSpec::IdFields::const_iterator it = m_idspec->IdFieldsBegin();
-            it != m_idspec->IdFieldsEnd();
-            it++ ) {
-          os << " " << (*it)->getLabel();
-      }
-      os << std::endl;
-  }
-  else 
-  {
-      os << "idspec points to null!" << std::endl;
-  }
-                    
-  return os;
-}
-                
-Id64bit G4SensitiveDetector::makeId() const 
-{
-  Id64bit id64;
-                    
-  if ( hasIdSpec() ) {
-                        
-    // get idvec ordered by this idspec
-    const IdVec ids = IdFactory::createOrderedIdVec( step(), this );
-                        
-    // pack into 64 bit cell id
-    id64 = IdFactory::createId64bit( ids, getIdSpec() );
-  }
-                    
-  return id64;
-}
-                
-G4VHitsCollection* G4SensitiveDetector::getHitsCollection() const 
-{
-  G4VHitsCollection* hc = 0;
-  if ( this->getHCID() != -1 ) {
-    hc = G4EventManager::GetEventManager()->GetConstCurrentEvent()->GetHCofThisEvent()->GetHC( this->getHCID() );
-  }
-  return hc;
-}
-
-G4VHitsCollection* G4SensitiveDetector::getHitsCollection(G4int nHC) const 
-{
-  G4VHitsCollection* hc = 0;
-  if ( this->getHCID(nHC) != -1 ) {
-    hc = G4EventManager::GetEventManager()->GetConstCurrentEvent()->GetHCofThisEvent()->GetHC( this->getHCID(nHC) );
-  }
-  return hc;

+    G4VHitsCollection* hc = 0;
+    if (this->getHCID() != -1) {
+        hc = G4EventManager::GetEventManager()->GetConstCurrentEvent()->GetHCofThisEvent()->GetHC(
+                this->getHCID());
+    }
+    return hc;

 }
 

-std::ostream& G4SensitiveDetector::printNumberOfHits(std::ostream& os) 

+G4VHitsCollection* G4SensitiveDetector::getHitsCollection(G4int nHC) const
+        {
+    G4VHitsCollection* hc = 0;
+    if (this->getHCID(nHC) != -1) {
+        hc = G4EventManager::GetEventManager()->GetConstCurrentEvent()->GetHCofThisEvent()->GetHC(
+                this->getHCID(nHC));
+    }
+    return hc;
+}
+
+std::ostream& G4SensitiveDetector::printNumberOfHits(std::ostream& os)

 {

-    for (int i = 0; i < getNumberOfHitsCollections(); i++) 
-    {

+    for (int i = 0; i < getNumberOfHitsCollections(); i++)
+            {

         os << getHitsCollection(i)->GetName() << " " << getHitsCollection(i)->GetSize() << std::endl;
     }
     return os;
 }

-                
-std::ostream& G4SensitiveDetector::printEdep(std::ostream& os) 

+
+std::ostream& G4SensitiveDetector::printEdep(std::ostream& os)

 {

-  os << "total edep: " << G4BestUnit( this->getEdep(), "Energy" ) << std::endl;
-  return os;

+    os << "total edep: " << G4BestUnit(this->getEdep(), "Energy") << std::endl;
+    return os;

 }

-                
-std::vector<G4LogicalVolume*> G4SensitiveDetector::getLogicalVolumes() const 

+
+std::vector<G4LogicalVolume*> G4SensitiveDetector::getLogicalVolumes() const

 {

-  std::vector<G4LogicalVolume*> volumes;
-  for ( G4LogicalVolumeStore::const_iterator it = G4LogicalVolumeStore::GetInstance()->begin();
-	it != G4LogicalVolumeStore::GetInstance()->end();
-	it++ ) {
-    if ( (*it)->GetSensitiveDetector() == this ) {
-      volumes.push_back( *it );
-    }
-  }
-  return volumes;
-}
-                
-std::ostream& G4SensitiveDetector::printVolumes(std::ostream& os) 
-{
-  std::vector<G4LogicalVolume*> volumes = this->getLogicalVolumes();
-                    
-  for ( std::vector<G4LogicalVolume*>::const_iterator it = volumes.begin();
-	it != volumes.end();
-	it++ ) {
-    std::cout << (*it)->GetName() << std::endl;
-  }
-  return os;

+    std::vector<G4LogicalVolume*> volumes;
+    for (G4LogicalVolumeStore::const_iterator it = G4LogicalVolumeStore::GetInstance()->begin();
+            it != G4LogicalVolumeStore::GetInstance()->end();
+            it++) {
+        if ((*it)->GetSensitiveDetector() == this) {
+            volumes.push_back(*it);
+        }
+    }
+    return volumes;
+}
+
+std::ostream& G4SensitiveDetector::printVolumes(std::ostream& os)
+{
+    std::vector<G4LogicalVolume*> volumes = this->getLogicalVolumes();
+
+    for (std::vector<G4LogicalVolume*>::const_iterator it = volumes.begin();
+            it != volumes.end();
+            it++) {
+        std::cout << (*it)->GetName() << std::endl;
+    }
+    return os;

 }

diff -u -r1.29 -r1.30
--- LCDDLibLoad.cc	3 Oct 2012 00:48:25 -0000	1.29
+++ LCDDLibLoad.cc	30 May 2013 00:04:12 -0000	1.30
@@ -31,6 +31,7 @@

 	LOAD_COMPONENT(projective_zplaneProcess);
 	LOAD_COMPONENT(nonprojective_cylinderProcess);
 	LOAD_COMPONENT(global_grid_xyProcess);

+	LOAD_COMPONENT(cell_readout_2dProcess);

 
 	// Ids
 	LOAD_COMPONENT(idspecProcess);

diff -u -r1.23 -r1.24
--- SensitiveDetectorFactory.cc	1 Feb 2012 10:28:56 -0000	1.23
+++ SensitiveDetectorFactory.cc	30 May 2013 00:04:12 -0000	1.24
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/lcdd/src/SensitiveDetectorFactory.cc,v 1.23 2012/02/01 10:28:56 jeremy Exp $

+// $Header: /cvs/lcd/lcdd/src/SensitiveDetectorFactory.cc,v 1.24 2013/05/30 00:04:12 jeremy Exp $

 #include "SensitiveDetectorFactory.hh"
 
 // lcdd

@@ -13,98 +13,90 @@

 #include "StringUtil.hh"
 
 G4SensitiveDetector* SensitiveDetectorFactory::createSensitiveDetector(

-        const SAXObject* object )

+        const SAXObject* object)

 {

+    //std::cout << "create SD" << std::endl;
+

     G4SensitiveDetector* sd = 0;
 
     const SensitiveDetectorType* sdt =

-            dynamic_cast< const SensitiveDetectorType* > ( object );

+            dynamic_cast<const SensitiveDetectorType*>(object);

-    if ( sdt )
-    {

+    if (sdt) {

 
         std::string sd_type = sdt->get_type();
 
         /* Create calorimeter subdetector. */
         // TODO Check if "calorimeter" in the sd_type.

-        if ( sd_type == "calorimeter" || sd_type == "optical_calorimeter" || sd_type
-                == "unsegmented_calorimeter" )
-        {
-            sd = createCalorimeterSD( object );

+        if (sd_type == "calorimeter" || sd_type == "optical_calorimeter" || sd_type == "unsegmented_calorimeter") {
+            //std::cout << "creating calorimeter" << std::endl;
+            sd = createCalorimeterSD(object);

         }
         /* Create tracker subdetector. */

-        else if ( sd_type == "tracker" )
-        {
-            sd = createTrackerSD( object );

+        else if (sd_type == "tracker") {
+            sd = createTrackerSD(object);

         }
         /* Create scorer subdetector. */

-        else if ( sd_type == "scorer" )
-        {
-            sd = createScorerSD( object );
-        }
-        /* Type not recognized. */
-        else
-        {

+        else if (sd_type == "scorer") {
+            sd = createScorerSD(object);
+        } else {
+            /* Type not recognized. */

             G4cerr << "Invalid sd_type <" << sd_type << ">." << G4endl;

-            G4Exception( "", "", FatalException, "Unknown SD type.  Check the LCDD file." );

+            G4Exception("", "", FatalException, "Unknown SD type.  Check the LCDD file.");

         }
 
         // set ecut and verbose

-        setBaseSensitiveDetectorAttributes( sd, sdt );

+        setBaseSensitiveDetectorAttributes(sd, sdt);

 
         // find idspec

-        IdSpec* idspec = findIdSpec( sdt );

+        IdSpec* idspec = findIdSpec(sdt);

 
         // set idspec, if exists (null is ok)

-        if ( idspec != 0 )
-        {
-            sd->setIdSpec( idspec );

+        if (idspec != 0)
+                {
+            sd->setIdSpec(idspec);

         }
 
         // register the SD
         std::string sdName = sd->GetName();

-        LCDDProcessor::instance()->addSensitiveDetector( sdName, sd );
-    }
-    else
-    {

+        LCDDProcessor::instance()->addSensitiveDetector(sdName, sd);
+    } else {

         G4Exception("", "", FatalException, "Failed cast to SensitiveDetectorType.");
     }
 
     return sd;
 }
 

-G4CalorimeterSD* SensitiveDetectorFactory::createCalorimeterSD( const SAXObject* object )

+G4CalorimeterSD* SensitiveDetectorFactory::createCalorimeterSD(const SAXObject* object)

 {
     G4CalorimeterSD* sd = 0;
     G4Segmentation* seg = 0;
 
     const SensitiveDetectorType* sdt =

-            dynamic_cast< const SensitiveDetectorType* > ( object );

+            dynamic_cast<const SensitiveDetectorType*>(object);

 
     std::string sd_type = sdt->get_type();
 
     // Create the segmentation.

-    ContentSequence* seq = const_cast< ContentSequence* > ( sdt->get_content() );

+    ContentSequence* seq = const_cast<ContentSequence*>(sdt->get_content());

     size_t count = seq->size();
 
     // Look for segmentation tag.
     bool fnd_seg = false;

-    for ( size_t i = 0; i < count; i++ )
-    {
-        std::string child_tag = seq->content( i ).tag;
-        const ContentGroup::ContentItem& segitem = seq->content( i );

+    for (size_t i = 0; i < count; i++) {
+        std::string child_tag = seq->content(i).tag;
+        const ContentGroup::ContentItem& segitem = seq->content(i);

 
         // Create segmentation using factory.

-        if ( isSegmentationTag( child_tag ) )
-        {
-            seg = G4SegmentationFactory::createSegmentation( segitem.object, segitem.tag );

+        if (isSegmentationTag(child_tag)) {
+            seg = G4SegmentationFactory::createSegmentation(segitem.object, segitem.tag);

             fnd_seg = true;
             break;
         }
     }
 
     // Get the calorimeter XML object.

-    const calorimeter* cal = dynamic_cast< const calorimeter* > ( object );

+    const calorimeter* cal = dynamic_cast<const calorimeter*>(object);

 
     // Find out hit aggregation algorithm.
     const std::string& hitCompareStr = cal->get_compare();

@@ -113,23 +105,19 @@

     HitComparator* hitCompare = 0;
 
     // Find the IdSpec.

-    IdSpec* idspec = findIdSpec( sdt );

+    IdSpec* idspec = findIdSpec(sdt);

-    if ( hitCompareStr != "id" && hitCompareStr != "position" )
-    {
-        G4cerr << "Invalid selection for hit comparison <" << hitCompareStr << ">, for calorimeter <" << sdt->get_name() << ">." << G4endl;

+    if (hitCompareStr != "id" && hitCompareStr != "position") {
+        G4cerr << "Invalid selection for hit comparison <" << hitCompareStr << ">, for calorimeter <"
+                << sdt->get_name() << ">." << G4endl;

         G4Exception("", "", FatalException, "Invalid selection for hit comparison.");
     }
 
     // Compare on IDs.

-    if ( hitCompareStr == "id" )
-    {
-        if ( idspec )
-        {

+    if (hitCompareStr == "id") {
+        if (idspec) {

             hitCompare = new IdComparator();

-        }
-        else
-        {

+        } else {

             std::cerr << "WARNING: IdSpec for <" << sdt->get_name()
                     << "> does not exist!  Position comparison will be used for hit aggregation instead of id."
                     << std::endl;

@@ -137,43 +125,35 @@

     }
 
     // Compare on position.

-    if ( !hitCompare )
-    {

+    if (!hitCompare) {

         hitCompare = new PositionComparator();
     }
 

-    if ( sd_type == "calorimeter" )
-    {

+    if (sd_type == "calorimeter") {

         sd = new G4CalorimeterSD(
                 sdt->get_name(),
                 sdt->get_hitsCollectionName(),
                 seg,

-                hitCompare );

+                hitCompare);

     }

-    else if ( sd_type == "optical_calorimeter" )
-    {

+    else if (sd_type == "optical_calorimeter") {

         //
         // in case of optical alorimeter there are 2 hit collections
         //
         //G4String  hcnames[2];
         // TODO Fix hardcoded collection names.

-        std::vector< G4String > hcnames;
-        hcnames.push_back( "Edep_" + sdt->get_hitsCollectionName() );
-        hcnames.push_back( "Ceren_" + sdt->get_hitsCollectionName() );

+        std::vector<G4String> hcnames;
+        hcnames.push_back("Edep_" + sdt->get_hitsCollectionName());
+        hcnames.push_back("Ceren_" + sdt->get_hitsCollectionName());

         //std::cout<< " now creating optical calorimeter"<<std::endl;

-        sd = new G4OpticalCalorimeterSD( sdt->get_name(), hcnames, seg, hitCompare );
-    }
-    else if ( sd_type == "unsegmented_calorimeter" )
-    {

+        sd = new G4OpticalCalorimeterSD(sdt->get_name(), hcnames, seg, hitCompare);
+    } else if (sd_type == "unsegmented_calorimeter") {

         // Segmentation could be null but that is fine for this type of calorimeter.
         sd = new G4UnsegmentedCalorimeterSD(
                 sdt->get_name(),
                 sdt->get_hitsCollectionName(),

-                seg );
-    }
-    else
-    {
-

+                seg);
+    } else {

         G4cerr << "Unknown sensitive detector type: " << sd_type << G4endl;
         G4Exception("SensitiveDetectorFactory", "", FatalException, "Unknown sensitive detector type.");
     }

@@ -181,75 +161,70 @@

     return sd;
 }
 

-G4TrackerSD* SensitiveDetectorFactory::createTrackerSD( const SAXObject* object )

+G4TrackerSD* SensitiveDetectorFactory::createTrackerSD(const SAXObject* object)

 {

-    const tracker* trk = dynamic_cast< const tracker* > ( object );

+    const tracker* trk = dynamic_cast<const tracker*>(object);

-    bool combineHits = StringUtil::toBool( trk->get_combine_hits() );

+    bool combineHits = StringUtil::toBool(trk->get_combine_hits());

 
     G4TrackerSD* sd = 0;
 
     std::string nm = trk->get_name();
     std::string hc = trk->get_hitsCollectionName();
 

-    if ( checkHCName( hc ) )
-    {
-        G4Exception("SensitiveDetectorFactory", "", FatalException, "Name of the hits collection is invalid.");

+    if (checkHCName(hc)) {
+        G4Exception("SensitiveDetectorFactory", "", FatalException,
+                "Name of the hits collection is invalid.");

     }
 
     /* tracker that aggregates hits */

-    if ( combineHits )
-    {
-        sd = new G4TrackerCombineSD( nm, hc );
-    }
-    /* regular tracker */
-    else
-    {
-        sd = new G4TrackerSD( nm, hc );

+    if (combineHits) {
+        sd = new G4TrackerCombineSD(nm, hc);
+    } else {
+        /* regular tracker */
+        sd = new G4TrackerSD(nm, hc);

     }
 
     return sd;
 }
 

-G4ScorerSD* SensitiveDetectorFactory::createScorerSD( const SAXObject* object )

+G4ScorerSD* SensitiveDetectorFactory::createScorerSD(const SAXObject* object)

 {

-    const scorer * scr = dynamic_cast< const scorer* > ( object );

+    const scorer * scr = dynamic_cast<const scorer*>(object);

 
     G4ScorerSD* sd = 0;
 
     std::string nm = scr->get_name();
     std::string hc = scr->get_hitsCollectionName();
 

-    if ( checkHCName( hc ) )
-    {
-        G4Exception("SensitiveDetectorFactory", "", FatalException, "Name of the hits collections is invalid.");

+    if (checkHCName(hc)) {
+        G4Exception("SensitiveDetectorFactory", "", FatalException,
+                "Name of the hits collections is invalid.");

     }
 

-    sd = new G4ScorerSD( nm, hc );

+    sd = new G4ScorerSD(nm, hc);

     return sd;
 }
 

-IdSpec* SensitiveDetectorFactory::findIdSpec( const SensitiveDetectorType* sdt )

+IdSpec* SensitiveDetectorFactory::findIdSpec(const SensitiveDetectorType* sdt)

 {
     IdSpec* idspec = 0;

-    ContentSequence* seq = const_cast< ContentSequence* > ( sdt->get_content() );

+    ContentSequence* seq = const_cast<ContentSequence*>(sdt->get_content());

     size_t count = seq->size();

-    for ( size_t i = 0; i < count; i++ )
-    {

+    for (size_t i = 0; i < count; i++) {

-        std::string child_tag = seq->content( i ).tag;

+        std::string child_tag = seq->content(i).tag;

 
         // find idspec

-        if ( child_tag == "idspecref" )
-        {

+        if (child_tag == "idspecref") {

             IdSpecType::idspecref* id_ref =

-                    dynamic_cast< IdSpecType::idspecref* > ( seq->content( i ).object );

+                    dynamic_cast<IdSpecType::idspecref*>(seq->content(i).object);

-            idspec = IdManager::instance()->getIdSpec( id_ref->get_ref() );

+            idspec = IdManager::instance()->getIdSpec(id_ref->get_ref());

-            if ( idspec == 0 )
-            {
-                G4cerr << "IdSpec <" << id_ref->get_ref() << "> referenced by detector <" << sdt->get_name() << "> does not exist." << G4endl;

+            if (idspec == 0) {
+                G4cerr << "IdSpec <" << id_ref->get_ref() << "> referenced by detector <" << sdt->get_name()
+                        << "> does not exist." << G4endl;

                 G4Exception("", "", FatalException, "IdSpec does not exist.");
             }
 

@@ -261,63 +236,58 @@

 
 void SensitiveDetectorFactory::setBaseSensitiveDetectorAttributes(
         G4SensitiveDetector* sd,

-        const SensitiveDetectorType* sdt )

+        const SensitiveDetectorType* sdt)

 {

-    sd->setEcut( SensitiveDetectorFactory::computeEcut( sdt ) );
-    sd->setVerbose( SensitiveDetectorFactory::convertVerbose( sdt ) );
-    sd->setEndcapFlag( StringUtil::toBool( sdt->get_endcap_flag() ) );

+    sd->setEcut(SensitiveDetectorFactory::computeEcut(sdt));
+    sd->setVerbose(SensitiveDetectorFactory::convertVerbose(sdt));
+    sd->setEndcapFlag(StringUtil::toBool(sdt->get_endcap_flag()));

 }
 

-double SensitiveDetectorFactory::computeEcut( const SensitiveDetectorType* sdt )

+double SensitiveDetectorFactory::computeEcut(const SensitiveDetectorType* sdt)

 {
     GDMLExpressionEvaluator* calc = GDMLProcessor::GetInstance()->GetEvaluator();
     std::string sval = sdt->get_ecut();
     sval += "*" + sdt->get_eunit();

-    double ecut = calc->Eval( sval );

+    double ecut = calc->Eval(sval);

     return ecut;
 }
 

-int SensitiveDetectorFactory::convertVerbose( const SensitiveDetectorType* sdt )

+int SensitiveDetectorFactory::convertVerbose(const SensitiveDetectorType* sdt)

 {
     GDMLExpressionEvaluator* calc = GDMLProcessor::GetInstance()->GetEvaluator();
     std::string sval = sdt->get_verbose();

-    int verbose = ( int ) calc->Eval( sval );

+    int verbose = (int) calc->Eval(sval);

     return verbose;
 }
 
 // NOTE: New segmentations must appear here!

-bool SensitiveDetectorFactory::isSegmentationTag( const std::string& s )

+bool SensitiveDetectorFactory::isSegmentationTag(const std::string& s)

 {
     // @todo Fix this to know all segmentation types automatically somehow.  (schema?)

-    return ( s == "projective_cylinder" || s == "grid_xyz" || s == "global_grid_xy" || s
-            == "nonprojective_cylinder" || s == "projective_zplane" );

+    return (s == "projective_cylinder" || s == "grid_xyz" || s == "global_grid_xy" || s
+            == "nonprojective_cylinder" || s == "projective_zplane" || s == "cell_readout_2d");

 }
 

-bool SensitiveDetectorFactory::checkHCName( const std::string& s )

+bool SensitiveDetectorFactory::checkHCName(const std::string& s)

 {
     bool bad = false;
 
     // is size <= 1 ?

-    if ( s.size() <= 1 )
-    {

+    if (s.size() <= 1) {

         bad = true;
         //std::cerr << "HCName <" << s << "> is not enough characters." << std::endl;
     }

-    else
-    {

+    else {

         LCDDProcessor* proc = LCDDProcessor::instance();

-        for ( LCDDProcessor::SensitiveDetectors::const_iterator iter =

+        for (LCDDProcessor::SensitiveDetectors::const_iterator iter =

                 proc->getSensitiveDetectorsBegin(); iter

-                != proc->getSensitiveDetectorsBegin(); iter++ )
-        {
-            if ( iter->second->getHCName() == s )
-            {

+                != proc->getSensitiveDetectorsBegin(); iter++) {
+            if (iter->second->getHCName() == s) {

                 bad = true;
                 //std::cerr << "HCName <" << s << "> already assigned to SD <" << iter->second->GetName() << ">." << std::endl;
                 break;
             }
         }
     }

-

     return bad;
 }

diff -u -r1.15 -r1.16
--- calorimeterSubscriber.cc	30 Mar 2006 19:43:58 -0000	1.15
+++ calorimeterSubscriber.cc	30 May 2013 00:04:12 -0000	1.16
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/lcdd/src/calorimeterSubscriber.cc,v 1.15 2006/03/30 19:43:58 jeremy Exp $

+// $Header: /cvs/lcd/lcdd/src/calorimeterSubscriber.cc,v 1.16 2013/05/30 00:04:12 jeremy Exp $

 
 // GDML
 #include "Saxana/SAXSubscriber.h"

@@ -22,32 +22,33 @@

 #include <sstream>
 
 /**

-   @class calorimeterSubscriber
-   @brief SAX subscriber for calorimeter element.
-   @note  Delegates to SensitiveDetectorFactory to create G4CalorimeterSD object.
-*/
-class calorimeterSubscriber : virtual public SAXSubscriber

+ @class calorimeterSubscriber
+ @brief SAX subscriber for calorimeter element.
+ @note  Delegates to SensitiveDetectorFactory to create G4CalorimeterSD object.
+ */
+class calorimeterSubscriber: virtual public SAXSubscriber

 {
 public:

-  virtual const SAXComponentObject* Build() const
-  {
-    return this;
-  }

+    virtual const SAXComponentObject* Build() const
+    {
+        return this;
+    }

 
 public:

-  calorimeterSubscriber()
-  {
-    Subscribe("calorimeter");
-  }
-
-  virtual ~calorimeterSubscriber()
-  {}
-
-  virtual void Activate(const SAXObject* object)
-  {
-    // use factory to create this SD
-    SensitiveDetectorFactory::createSensitiveDetector( object );
-  }

+    calorimeterSubscriber()
+    {
+        Subscribe("calorimeter");
+    }
+
+    virtual ~calorimeterSubscriber()
+    {
+    }
+
+    virtual void Activate(const SAXObject* object)
+    {
+        // use factory to create this SD
+        SensitiveDetectorFactory::createSensitiveDetector(object);
+    }

 };
 
 DECLARE_SUBSCRIBER_FACTORY(calorimeterSubscriber)