Author: [log in to unmask] Date: Mon May 23 15:29:37 2016 New Revision: 4369 Log: (empty) Modified: java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/CrystalTaitBryanAngleCalculator.java java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/GVector.java java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Geant4Position.java java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/StatFunUtils.java java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Transformations.java Modified: java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/CrystalTaitBryanAngleCalculator.java ============================================================================= --- java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/CrystalTaitBryanAngleCalculator.java (original) +++ java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/CrystalTaitBryanAngleCalculator.java Mon May 23 15:29:37 2016 @@ -26,9 +26,11 @@ private double cosPhi = 0; private double sinPhi = 0; - //contractor: the argument is the final state unitary vector, - //if not unit, it will be redefined as unitary - //initial state is defined as (0,0,1) vector, which is parallel to Z(beam direction) + /* constructor: + * @param vecFin final state unit vector, + * if not unit, it will be redefined as unitary, + * initial state is defined as (0,0,1) vector, which is parallel to Z(beam direction) + */ public CrystalTaitBryanAngleCalculator(GVector vecFin) { fin = vecFin; if (vecFin.isUnitary() == false) { @@ -38,14 +40,21 @@ this.theta = this.calculateTheta(); } - //calculates phi angle + /* + * calculates phi angle + * @return phi angle, rotation around X [rad] + */ private double calculatePhi() { sinPhi = -fin.y(); cosPhi = Math.sqrt(1 - this.sinPhi * this.sinPhi); return Math.asin(this.sinPhi); } - //calculates theta angle after phi is calculated + /* + * calculates theta angle after phi is calculated + * @return theta angle, rotation around Y [rad] + * + */ private double calculateTheta() { if (this.cosPhi == 0) { this.sinTheta = Double.NaN; @@ -55,22 +64,31 @@ return Math.asin(this.sinTheta); } - //returns value of theta in rad + /* + * @return value of theta [rad], rotation around Y + */ public double getTheta() { return this.theta; } - //returns value of phi anlge in rad + /* + * @return value of phi [rad], rotation around X + * / + */ public double getPhi() { return this.phi; } - //returns value of psi angle in rad + /* + * @return value of psi [rad], rotation around Z + */ public double getPsi() { return this.psi; } - //returns Tait-Bryan angles as a String in the format of (phi, theta, psi) + /* + * @return string of Tait-Bryan angles-(phi, theta, psi) [rad] + */ public String toString(){ return ("("+this.phi+","+this.theta+","+this.psi+")"); } Modified: java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/GVector.java ============================================================================= --- java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/GVector.java (original) +++ java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/GVector.java Mon May 23 15:29:37 2016 @@ -3,7 +3,7 @@ import hep.physics.vec.BasicHep3Vector; /** - * Defines a vector in (XYZ) coordinate system as a geometrical object. + * Define a vector in (XYZ) coordinate system as a geometrical object. * This class is similar to HepVector * * @author Annie Simonyan @@ -13,11 +13,16 @@ private double x = 0, y = 0, z = 0; private double[] vec; - //default constructor + /** + * default constructor + */ public GVector() { } - //constructor: argument - double[3]={x,y,z} array for vector coordinates + /** + * constructor + * @param double[3]={x,y,z} array for vector coordinates + */ public GVector(double[] array) { vec = array; this.x = array[0]; @@ -25,12 +30,21 @@ this.z = array[2]; } - //converts this Vvector to BasicHep3Vector + /** + * convert this GVector to BasicHep3Vector + * @return BasicHep3Vector object + */ public BasicHep3Vector getHepVector(){ return new BasicHep3Vector(this.x, this.y, this.z); } - //constructor: arguments - double(x,y,z) coordinates of vector + /** + * constructor: + * @param x - x coordinates of vector + * @param y - y coordinates of vector + * @param z - z coordinates of vector + * + */ public GVector(double x, double y, double z) { this.x = x; this.y = y; @@ -53,78 +67,120 @@ return z; } - //set vector x coordinate + /** + * set vector x coordinate + * @param x vector x coordinate + */ public void SetX(double x) { this.x = x; } - //set vector y coordinate + + /** + * set vector y coordinate + * @param y vector y coordinate + */ public void SetY(double y) { this.y = y; } - //set vector z coordinate + /** + * set vector z coordinate + *@param z vector z coordinate + */ public void SetZ(double z) { this.z = z; } - //set vector (x,y,z) coordinates + + /** + * set vector (x,y,z) coordinate + * @param x vector x coordinate + * @param y vector y coordinate + * @param z vector z coordinate + */ public void SetXYZ(double x, double y, double z) { this.x = x; this.y = y; this.z = z; } - //check if the vector is unit vector + /** + * check if the vector is unit vector + * @return true if the vector is unit vector + */ public boolean isUnitary() { return (Double.compare(StatFunUtils.round(this.Module(), 12), 1.0) == 0); } - //returns the module of the vector + /** + * @return the module of the vector + */ public double Module() { return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); } - //vector multiplication by cooficent k + /** + * multiplication by coefficient k + * @param k - multiplication coefficient + * @return new GVector=this*k + */ public GVector Multiply(double k) { return (new GVector(k * this.x, k * this.y, k * this.z)); } - //returns new vector = sum of this vector and argument vec2 + + /** + * sum of this vector and argument vec2 + * @param vec2 GVector to add + * @return new GVector = this+vec2 + */ public GVector Add(GVector vec2) { return (new GVector(this.x + vec2.x, this.y + vec2.y, this.z + vec2.z)); } - //returns new vector opposite to this vector + /** + * + * @return new vector opposite to this vector + */ public GVector getOpposite() { return (new GVector(-this.x, -this.y, -this.z)); } - //returns new vector = this vector - argument vector + /** + * substract GVectors + * @param vec2 GVector to substract + * @return new vector = this - vec2 + * + */ public GVector Substract(GVector vec2) { return (new GVector(this.x - vec2.x, this.y - vec2.y, this.z - vec2.z)); } - //returns new vector defined as translation of this vector by argument vector + /** + * @param trvec translation vector + * @return new GVector defined as translation of this vector by argument vector + * newVector = this+trvec + */ public GVector TranslateBy(GVector trvec) { - // return this.Substract(trvec); + return this.Add(trvec); } - /* - * Returns new vector = this vector rotated by (alpha, betta, gamma) rotation + /** + * Rotate this vector by (alpha, betta, gamma) rotation angles * (Rz-alpha,Ry-beta,Rx-gamma) - * - * Vector rotation defined as: - * alpha-rotation around Z axis - * beta-rotation around Y axis - * gamma-rotation around X axis + * + * @param alpha rotation around Z axis + * @param beta rotation around Y axis + * @param gamma rotation around X axis + * @return new GVector=this vector rotated by (alpha, betta, gamma) */ public GVector RotateBy(double alpha, double betta, double gamma) { @@ -150,17 +206,26 @@ return (new GVector(xx, yy, zz)); } - // returns scaliar multiplication of vectors - public double ScaliarM(GVector vec2) { + /** + * scalar multiplication of this vector by vec2 + * @param vec2 GVector + * @return double = (this vector * vec2 vector) + * + */ + public double ScalarM(GVector vec2) { return this.x * vec2.x + this.y * vec2.y + this.z * vec2.z; } - //returns angle between vectors in rad + /** + * Calculate angle between vectors + * @param vec2 GVector to calc. angle with this + * @return angle between this and vec2 vectors [rad] + */ public double Angle(GVector vec2) { // System.out.print("Scaliar= "+this.ScaliarM(vec2) +" modN1 = "+this.Module()+" modN2 = "+vec2.Module()+"\n"); // System.out.print(this.ScaliarM(vec2)/(this.Module()*vec2.Module())+ "\n"); // System.out.println(Math.acos(this.ScaliarM(vec2)/(this.Module()*vec2.Module()))); - double cosAlpha = this.ScaliarM(vec2) / (this.Module() * vec2.Module()); + double cosAlpha = this.ScalarM(vec2) / (this.Module() * vec2.Module()); if (Double.compare(StatFunUtils.round(cosAlpha, 12), 1.0) == 0) { cosAlpha = 1.0; @@ -171,28 +236,43 @@ return Math.acos(cosAlpha); } - //returns coordinates of this vector as an array of doubles + /** + * + * @return coordinates of this vector as an array + */ public double[] getVector() { return this.vec; } - //returns new vector, which is unit vector of this vector + /** + * Calculate unit vector of this vector + * @return new GVector, which is unit vector of this vector + * + */ public GVector getUnitVector() { return new GVector(this.x / this.Module(), this.y / this.Module(), this.z / this.Module()); } - //returns the center coordinates of this vector as a Vvector object + /** + * + * @return new GVector = coordinates of center of this vector as a GVector object + * + */ public GVector getCenter() { return (this.Multiply(0.5)); } - //Print the coordinates of the Vector as (x,y,z) + /** + * Print the coordinates of the GVector as (x,y,z) + */ public void Print() { System.out.println("(" + this.x + ", " + this.y + ", " + this.z + ")"); } - //returns coordinates of the vector as a String "(x,y,z)" + /** + * @return String of coordinates of this vector + */ public String toString(){ return ("(" + this.x + ", " + this.y + ", " + this.z + ")"); } Modified: java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Geant4Position.java ============================================================================= --- java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Geant4Position.java (original) +++ java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Geant4Position.java Mon May 23 15:29:37 2016 @@ -2,30 +2,34 @@ /** - * Calculates G4 position for a crystal, by it's front and back face coordinates calculates the position for the center + * Calculate G4 position for a crystal, by it's front and back face coordinates calculates the position for the center * of the crystal calculates the rotation of the crystal in convention of Tait-Bryan angles, {phi, theta, psi} * - * or look here: http://sedris.org/wg8home/Documents/WG80485.pdf - * - * Brief: * phi-rotation around X * theta-rotation around Y * psi-rotation around Z * * @author Annie Simonyan */ -// FIXME: There is not anything specific to Geant4 about this class, so it should be renamed. + public final class Geant4Position { - private GVector centerPoint; // center coordinate - private GVector crysvec; // crystal vector formed by front face center point and back face center point - private double[] taitbriangles; // { phi,theta,psi=0}; Tait-Bryan angles to define crystal orientation in the space - private double[] centerArr; //crystal center coordinates as a double[3] array - - //contsructor arguments - //1 Vector - (x,y,z) of crystal front face center point as Vector - //2 Vector - (x,y,z) of crystal back face center point as Vector - public Geant4Position(GVector point1, GVector point2) { + /* center coordinates */ + private GVector centerPoint; + /* crystal vector formed by front face center point and back face center point*/ + private GVector crysvec; + /* { phi,theta,psi=0}; Tait-Bryan angles to define crystal orientation in the space */ + private double[] taitbriangles; + + /* crystal center coordinates as a double[3] array */ + private double[] centerArr; + + /** + * constructor + * @param point1 (x,y,z) of crystal front face center point as GVector + * @param point2 (x,y,z) of crystal back face center point as GVector + */ + public Geant4Position(GVector point1, GVector point2) { centerPoint = point2.Add(point1).Multiply(0.5); centerArr = new double[3]; centerArr[0] = centerPoint.x(); @@ -36,23 +40,38 @@ this.calculateTaitBryanAngles(); } - //returns the center coordinates as a Vector - public GVector getCenter() { + + /** + * + * @return center coordinates as a GVector + */ + public GVector getCenter() { return this.centerPoint; } - //returns center coordinates as an array of doubles - public double[] getCenterArr() { + + + /** + * + * @return center coordinates as an array double[x_center, y_center, z_center] + */ + public double[] getCenterArr() { return centerArr; } - //returns Tait-Bryan angles as an array of doubles [phi, theta, psi] - public double[] getTaitBryanAngles() { + + /** + * + * @return Tait-Bryan angles as an array doubles [phi, theta, psi] + */ + public double[] getTaitBryanAngles() { return this.taitbriangles; } - //calculates Tait-Bryan angles for the object orientation defined by initial and final state vectors - //throws arithmetical exception if the phi angle is calculated wrong or 0 + /* + * calculates Tait-Bryan angles for the object orientation defined by initial and final state vectors + * throws arithmetical exception if the phi angle is calculated wrong or 0 + */ private void calculateTaitBryanAngles() throws ArithmeticException{ CrystalTaitBryanAngleCalculator crysTBang = new CrystalTaitBryanAngleCalculator(crysvec); if (crysTBang.getPhi() == Double.NaN) { @@ -63,13 +82,21 @@ this.taitbriangles[2] = -crysTBang.getPsi(); } - //Print crystal center coordinates(X,Y,Z) and Tait-Bryan angles - public void Print() { + + /** + * Print crystal center coordinates(X,Y,Z) and Tait-Bryan angles + */ + public void Print() { this.centerPoint.Print(); } - //return Geant4Position object attributes as a String - public String toString(){ + + + /** + * + * @return String of Geant4Position object attributes + */ + public String toString(){ return ("\"Crys Center coordinates:\\t\""+this.centerPoint.toString()+"Tait Brian angles phi = " + Math.toDegrees(this.taitbriangles[0]) + "\t theta = " + Math.toDegrees(this.taitbriangles[1]) + "\t psi = " + Math.toDegrees(this.taitbriangles[2]) + "\n"); } Modified: java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/StatFunUtils.java ============================================================================= --- java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/StatFunUtils.java (original) +++ java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/StatFunUtils.java Mon May 23 15:29:37 2016 @@ -9,6 +9,9 @@ /** * Function for double to round up the arg. value to 'places' digits after the semicolon + * @param value double number to round + * @param places round up to places + * @return rounded value */ public static double round(double value, int places) { if (places < 0 || places > 16) { Modified: java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Transformations.java ============================================================================= --- java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Transformations.java (original) +++ java/branches/HPSJAVA-409/detector-model/src/main/java/org/hps/detector/ecal/Transformations.java Mon May 23 15:29:37 2016 @@ -17,6 +17,7 @@ /* vector of translation */ private GVector transVec; + /* array with rotation angles */ private double[] rotation; /* geometrically defined center mass of top module */ @@ -35,6 +36,13 @@ this.rotation = rot; } + /** + * perform rotation and translation operation for a single crystal + * + * @param position crystal position + * @param channel crystal channel + * @return crystal position in G4 conventions + */ public Geant4Position transformToGeant4(EcalCrystalPosition position, EcalChannel channel) { // Define untransformed front and back positions.