[u/mrichter/AliRoot.git] / ITS / AliITSgeomSSD.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

////////////////////////////////////////////////////////////////////////
// This class is for the Silicon Strip Detector, SSD, specific geometry.
// It is being replaced by AliITSsegmentationSSD class. This file also
// constains classes derived from AliITSgeomSSD which do nothing but
// initilize this one with predefined values.
////////////////////////////////////////////////////////////////////////

#include <Riostream.h>
#include <stdlib.h>
#include <TShape.h>
#include <TBRIK.h>

#include "AliITSgeomSSD.h"

ClassImp(AliITSgeomSSD)


AliITSgeomSSD::AliITSgeomSSD(){
// Default constructor
    fShapeSSD = 0;
    fNp       = 0;
    fNn       = 0;
    fLowEdgeP = 0;
    fLowEdgeN = 0;
    fAngleP   = 0.0;
    fAngleN   = 0.0;
}
//----------------------------------------------------------------------
AliITSgeomSSD::AliITSgeomSSD(const Float_t *box,Float_t ap,Float_t an,
			     Int_t np,Float_t *p,Int_t nn,Float_t *n){
////////////////////////////////////////////////////////////////////////
//    Standard Constructor. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
// nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
// np= number of anodes+1, *p= array of anode low edges+lighest edge.
///////////////////////////////////////////////////////////////////////
    fShapeSSD = 0;
    fNp       = 0;
    fNn       = 0;
    fLowEdgeP = 0;
    fLowEdgeN = 0;
    fAngleP   = 0.0;
    fAngleN   = 0.0;
    ResetSSD(box,ap,an,np,p,nn,n);
}
//----------------------------------------------------------------------
void AliITSgeomSSD::ResetSSD(const Float_t *box,Float_t ap,Float_t an,
			     Int_t np,Float_t *p,Int_t nn,Float_t *n){
////////////////////////////////////////////////////////////////////////
//    Standard Filler. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
// nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
// np= number of anodes+1, *p= array of anode low edges+lighest edge.
///////////////////////////////////////////////////////////////////////
    Int_t i;

    fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
			  box[0],box[1],box[2]);
//    if(fLowEdgeP!=0) delete fLowEdgeP;
//    if(fLowEdgeN!=0) delete fLowEdgeN;
    fNp = np;
    fNn = nn;
    fAngleP = ap;
    fAngleN = an;
    fLowEdgeP = new Float_t[fNp];
    fLowEdgeN = new Float_t[fNn];
    for(i=0;i<fNp;i++) fLowEdgeP[i] = p[i];
    for(i=0;i<fNn;i++) fLowEdgeN[i] = n[i];
}
//______________________________________________________________________
AliITSgeomSSD::~AliITSgeomSSD(){
    // Destructor.

    if(fLowEdgeP) delete [] fLowEdgeP; fLowEdgeP = 0;
    if(fLowEdgeN) delete [] fLowEdgeN; fLowEdgeN = 0;
    if(fShapeSSD) delete  fShapeSSD; fShapeSSD = 0;
    fNp = 0;
    fNn = 0;
    fAngleP = 0.0;
    fAngleN = 0.0;
}
//______________________________________________________________________
AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
////////////////////////////////////////////////////////////////////////
//    copy  constructor
////////////////////////////////////////////////////////////////////////
    Int_t i;

    if(this == &source) return;
    this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
    this->fNp = source.fNp;
    this->fNn = source.fNn;
    delete fLowEdgeP;
    delete fLowEdgeN;
    this->fAngleP = source.fAngleP;
    this->fAngleN = source.fAngleN;
    fLowEdgeP = new Float_t[fNp];
    fLowEdgeN = new Float_t[fNn];
    for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
    for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
    return;
}  

AliITSgeomSSD& AliITSgeomSSD::operator=(const AliITSgeomSSD &source) {
////////////////////////////////////////////////////////////////////////
//    assignment operator
////////////////////////////////////////////////////////////////////////
    Int_t i;

    if(this == &source) return *this;
    this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
    this->fNp = source.fNp;
    this->fNn = source.fNn;
    delete fLowEdgeP;
    delete fLowEdgeN;
    this->fAngleP = source.fAngleP;
    this->fAngleN = source.fAngleN;
    fLowEdgeP = new Float_t[fNp];
    fLowEdgeN = new Float_t[fNn];
    for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
    for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
    return *this;
}
//______________________________________________________________________
void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
    // Given a GEANT detector local coordinate, cm, this function returns
    // the detector specific P and N side strip numbers.
    // Inputs are:
    // Float_t x   Geant detector local x coordinate in cm
    // Float_t z   Geant detector local z coordinate in cm
    // outputs are:
    // Int_t &a    Detector anode strip number (P side)
    // Int_t &c    Detector cathode strip number (N side)
    Float_t d,b;
    Int_t i;

    // project on to bonding edges.
    d = x*TMath::Cos(fAngleP)+z*TMath::Sin(fAngleP);
    b = x*TMath::Cos(fAngleN)+z*TMath::Sin(fAngleN);
    if(d<fLowEdgeP[0]) i=-1;
    else for(i=0;i<fNp;i++){
	if(fLowEdgeP[i]<d) break;
    } // end for i
    a = i;
    if(b<fLowEdgeN[0]) i=-1;
    else for(i=0;i<fNn;i++){
	if(fLowEdgeN[i]<b) break;
    } // end for i
    c = i;
    return;
}
//______________________________________________________________________
void AliITSgeomSSD::Det2Local(Int_t a,Int_t c,Float_t &x,Float_t &z){
//    Float_t d,b;
//    Int_t i;
    // use AliITSsegmentationSSD.

    x=a;
    z=c;
    Error("Det2Locat","Use AliITSsegmentationSSD");
    return;
}
//______________________________________________________________________
void AliITSgeomSSD::Print(ostream *os) const {
////////////////////////////////////////////////////////////////////////
// Standard output format for this class.
////////////////////////////////////////////////////////////////////////
    Int_t i;
#if defined __GNUC__
#if __GNUC__ > 2
    ios::fmtflags fmt;
#else
    Int_t fmt;
#endif
#else
#if defined __ICC || defined __ECC || defined _xlc_
    ios::fmtflags fmt;
#else
    Int_t fmt;
#endif
#endif

    fmt = os->setf(ios::scientific);  // set scientific floating point output
    *os << "TBRIK" << " ";
    *os << setprecision(16) << GetDx() << " ";
    *os << setprecision(16) << GetDy() << " ";
    *os << setprecision(16) << GetDz() << " ";
    *os << fNp << " " << fNn << " ";
    *os << setprecision(16) << fAngleP << " ";
    *os << setprecision(16) << fAngleN << " ";
    for(i=0;i<fNp;i++) *os << setprecision(16) << fLowEdgeP[i] << " ";
    for(i=0;i<fNn;i++) *os << setprecision(16) << fLowEdgeN[i] << " ";
    *os << endl;
    os->flags(fmt); // reset back to old formating.
    return;
}
//______________________________________________________________________
void AliITSgeomSSD::Read(istream *is){
////////////////////////////////////////////////////////////////////////
// Standard input format for this class.
////////////////////////////////////////////////////////////////////////
    Float_t dx,dy,dz;
    Int_t i;
    char shp[20];

    *is >> shp;
    *is >> dx >> dy >> dz;
    if(fShapeSSD!=0) delete fShapeSSD;
    fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
			    dx,dy,dz);
    *is >> fNp >> fNn;
    *is >> fAngleP >> fAngleN;
    if(fLowEdgeP !=0) delete fLowEdgeP;
    if(fLowEdgeN !=0) delete fLowEdgeN;
    fLowEdgeP = new Float_t[fNp];
    fLowEdgeN = new Float_t[fNn];
    for(i=0;i<fNp;i++) *is >> fLowEdgeP[i];
    for(i=0;i<fNn;i++) *is >> fLowEdgeN[i];
    return;
}
//----------------------------------------------------------------------
ostream &operator<<(ostream &os,AliITSgeomSSD &p){
////////////////////////////////////////////////////////////////////////
// Standard output streaming function.
////////////////////////////////////////////////////////////////////////

    p.Print(&os);
    return os;
}
//----------------------------------------------------------------------
istream &operator>>(istream &is,AliITSgeomSSD &r){
////////////////////////////////////////////////////////////////////////
// Standard input streaming function.
////////////////////////////////////////////////////////////////////////

    r.Read(&is);
    return is;
}
//======================================================================

ClassImp(AliITSgeomSSD175)

AliITSgeomSSD175::AliITSgeomSSD175() : AliITSgeomSSD(){
////////////////////////////////////////////////////////////////////////
//    default constructor
////////////////////////////////////////////////////////////////////////
    const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
    // Size of sensitive detector area x,y(thickness),z
    const Float_t kangle   = 0.0175; // angle in rad. of anode and cathodes
    const Float_t kpitch   = 0.0095;// cm anode separation.
    const Int_t   kNstrips = 768; // number of anode or cathode strips.
    Float_t *leA,*leC; // array of low edges anode and cathorde.
    Int_t i;

    leA = new Float_t[kNstrips+1];
    leC = new Float_t[kNstrips+1];
    leA[0] = -kDxyz[0];
    leA[1] = -kpitch*(0.5*kNstrips-1);
    leC[0] =  kDxyz[0];
    leC[1] =  kpitch*(0.5*kNstrips-1);
    for(i=1;i<kNstrips;i++){
	leA[i+1] = leA[i] + kpitch;
	leC[i+1] = leC[i] - kpitch;
    } // end for i
    leA[kNstrips] =  kDxyz[0];
    leC[kNstrips] = -kDxyz[0];
//    cout << "AliITSgeomSSD175 default creator called: start" << endl;
    AliITSgeomSSD::ResetSSD(kDxyz,kangle,-kangle,
				 kNstrips+1,leA,kNstrips+1,leC);
    delete leA;
    delete leC;
//    cout << "AliITSgeomSSD175 default creator called: end" << endl;
}
//________________________________________________________________________
ostream &operator<<(ostream &os,AliITSgeomSSD175 &p){
////////////////////////////////////////////////////////////////////////
// Standard output streaming function.
////////////////////////////////////////////////////////////////////////

    p.Print(&os);
    return os;
}
//----------------------------------------------------------------------
istream &operator>>(istream &is,AliITSgeomSSD175 &r){
////////////////////////////////////////////////////////////////////////
// Standard input streaming function.
////////////////////////////////////////////////////////////////////////

    r.Read(&is);
    return is;
}
//======================================================================

ClassImp(AliITSgeomSSD275and75)

AliITSgeomSSD275and75::AliITSgeomSSD275and75() : AliITSgeomSSD(){
////////////////////////////////////////////////////////////////////////
//    default constructor
////////////////////////////////////////////////////////////////////////
}
//----------------------------------------------------------------------
AliITSgeomSSD275and75::AliITSgeomSSD275and75(Int_t npar,Float_t *par) : 
                                                            AliITSgeomSSD(){
    // Default constructor for AliITSgeomSSD with strip angles of
    // 275 miliradians and 75 miliradians. This constructor initlizes
    // AliITSgeomSSD with the correct values. This is the miror image
    // of the AliITSgeomSSD75and275 class.
    const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
    // Size of sensitive detector area x,y(thickness),z
    const Float_t kangleA  = 0.0275; // angle in rad. of anode and cathodes
    const Float_t kangleC  = 0.0075; // angle in rad. of anode and cathodes
    const Float_t kpitch   = 0.0095;// cm anode separation.
    const Int_t   kNstrips = 768; // number of anode or cathode strips.
    Float_t *leA,*leC; // array of low edges anode and cathorde.
    Int_t i;

    if(npar<3){
	Error("AliITSgeomSSD275and75",
	      "npar=%d<3. array par must be [3] or larger.",npar);
	return;
    } // end if
    leA = new Float_t[kNstrips+1];
    leC = new Float_t[kNstrips+1];
    leA[0] = -kDxyz[0];
    leA[1] = -kpitch*(0.5*kNstrips-1);
    leC[0] =  kDxyz[0];
    leC[1] =  kpitch*(0.5*kNstrips-1);
    for(i=1;i<kNstrips;i++){
	leA[i+1] = leA[i] + kpitch;
	leC[i+1] = leC[i] - kpitch;
    } // end for i
    leA[kNstrips] =  kDxyz[0];
    leC[kNstrips] = -kDxyz[0];
//    cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
    AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
				 kNstrips+1,leA,kNstrips+1,leC);
    delete [] leA;
    delete [] leC;
//    cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
}
//________________________________________________________________________
ostream &operator<<(ostream &os,AliITSgeomSSD275and75 &p){
////////////////////////////////////////////////////////////////////////
// Standard output streaming function.
////////////////////////////////////////////////////////////////////////

    p.Print(&os);
    return os;
}
//----------------------------------------------------------------------
istream &operator>>(istream &is,AliITSgeomSSD275and75 &r){
////////////////////////////////////////////////////////////////////////
// Standard input streaming function.
////////////////////////////////////////////////////////////////////////

    r.Read(&is);
    return is;
}
//======================================================================

ClassImp(AliITSgeomSSD75and275)

AliITSgeomSSD75and275::AliITSgeomSSD75and275() : AliITSgeomSSD(){
////////////////////////////////////////////////////////////////////////
//    default constructor
////////////////////////////////////////////////////////////////////////
}
AliITSgeomSSD75and275::AliITSgeomSSD75and275(Int_t npar,Float_t *par) : 
                                                            AliITSgeomSSD(){
    // Default constructor for AliITSgeomSSD with strip angles of
    // 75 miliradians and 275 miliradians. This constructor initlizes
    // AliITSgeomSSD with the correct values. This is the miror image
    // of the AliITSgeomSSD275and75 class.
    const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
    // Size of sensitive detector area x,y(thickness),z
    const Float_t kangleA  = 0.0075; // angle in rad. of anode and cathodes
    const Float_t kangleC  = 0.0275; // angle in rad. of anode and cathodes
    const Float_t kpitch   = 0.0095;// cm anode separation.
    const Int_t   kNstrips = 768; // number of anode or cathode strips.
    Float_t *leA,*leC; // array of low edges anode and cathorde.
    Int_t i;

    if(npar<3){
	Error("AliITSgeomSSD75and275",
	      "npar=%d<3. array par must be [3] or larger.",npar);
	return;
    } // end if
    leA = new Float_t[kNstrips+1];
    leC = new Float_t[kNstrips+1];
    leA[0] = -kDxyz[0];
    leA[1] = -kpitch*(0.5*kNstrips-1);
    leC[0] =  kDxyz[0];
    leC[1] =  kpitch*(0.5*kNstrips-1);
    for(i=1;i<kNstrips;i++){
	leA[i+1] = leA[i] + kpitch;
	leC[i+1] = leC[i] - kpitch;
    } // end for i
    leA[kNstrips] =  kDxyz[0];
    leC[kNstrips] = -kDxyz[0];
//    cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
    AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
				 kNstrips+1,leA,kNstrips+1,leC);
    delete leA;
    delete leC;
//    cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
}
//________________________________________________________________________
ostream &operator<<(ostream &os,AliITSgeomSSD75and275 &p){
////////////////////////////////////////////////////////////////////////
// Standard output streaming function.
////////////////////////////////////////////////////////////////////////

    p.Print(&os);
    return os;
}
//----------------------------------------------------------------------
istream &operator>>(istream &is,AliITSgeomSSD75and275 &r){
////////////////////////////////////////////////////////////////////////
// Standard input streaming function.
////////////////////////////////////////////////////////////////////////

    r.Read(&is);
    return is;
}
//======================================================================
Commit	Line	Data
4c039060	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
88cb7938	16	/* $Id$ */
85f1e34a	17
	18	////////////////////////////////////////////////////////////////////////
	19	// This class is for the Silicon Strip Detector, SSD, specific geometry.
	20	// It is being replaced by AliITSsegmentationSSD class. This file also
	21	// constains classes derived from AliITSgeomSSD which do nothing but
	22	// initilize this one with predefined values.
	23	////////////////////////////////////////////////////////////////////////
	24
4ae5bbc4	25	#include <Riostream.h>
8253cd9a	26	#include <stdlib.h>
	27	#include <TShape.h>
	28	#include <TBRIK.h>
	29
58005f18	30	#include "AliITSgeomSSD.h"
	31
	32	ClassImp(AliITSgeomSSD)
31b8cd63	33
	34
	35	AliITSgeomSSD::AliITSgeomSSD(){
	36	// Default constructor
	37	fShapeSSD = 0;
	38	fNp = 0;
	39	fNn = 0;
	40	fLowEdgeP = 0;
	41	fLowEdgeN = 0;
	42	fAngleP = 0.0;
	43	fAngleN = 0.0;
	44	}
	45	//----------------------------------------------------------------------
8253cd9a	46	AliITSgeomSSD::AliITSgeomSSD(const Float_t *box,Float_t ap,Float_t an,
8253cd9a	47	Int_t np,Float_t p,Int_t nn,Float_t n){
a3d834a0	48	////////////////////////////////////////////////////////////////////////
8253cd9a	49	// Standard Constructor. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
	50	// nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
	51	// np= number of anodes+1, *p= array of anode low edges+lighest edge.
31b8cd63	52	///////////////////////////////////////////////////////////////////////
	53	fShapeSSD = 0;
	54	fNp = 0;
	55	fNn = 0;
	56	fLowEdgeP = 0;
	57	fLowEdgeN = 0;
	58	fAngleP = 0.0;
	59	fAngleN = 0.0;
	60	ResetSSD(box,ap,an,np,p,nn,n);
	61	}
	62	//----------------------------------------------------------------------
	63	void AliITSgeomSSD::ResetSSD(const Float_t *box,Float_t ap,Float_t an,
	64	Int_t np,Float_t p,Int_t nn,Float_t n){
	65	////////////////////////////////////////////////////////////////////////
	66	// Standard Filler. *box={dx,dy,dz}, ap=anode angle, an=cathode angle,
	67	// nn= number of cathodes+1,*n= array of cathode low edges+highest edge,
	68	// np= number of anodes+1, *p= array of anode low edges+lighest edge.
8253cd9a	69	///////////////////////////////////////////////////////////////////////
8253cd9a	70	Int_t i;
a3d834a0	71
a3d834a0	72	fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
8253cd9a	73	box[0],box[1],box[2]);
31b8cd63	74	// if(fLowEdgeP!=0) delete fLowEdgeP;
31b8cd63	75	// if(fLowEdgeN!=0) delete fLowEdgeN;
8253cd9a	76	fNp = np;
	77	fNn = nn;
	78	fAngleP = ap;
	79	fAngleN = an;
	80	fLowEdgeP = new Float_t[fNp];
	81	fLowEdgeN = new Float_t[fNn];
	82	for(i=0;i<fNp;i++) fLowEdgeP[i] = p[i];
	83	for(i=0;i<fNn;i++) fLowEdgeN[i] = n[i];
	84	}
	85	//______________________________________________________________________
	86	AliITSgeomSSD::~AliITSgeomSSD(){
	87	// Destructor.
	88
cd77595e	89	if(fLowEdgeP) delete [] fLowEdgeP; fLowEdgeP = 0;
	90	if(fLowEdgeN) delete [] fLowEdgeN; fLowEdgeN = 0;
	91	if(fShapeSSD) delete fShapeSSD; fShapeSSD = 0;
8253cd9a	92	fNp = 0;
	93	fNn = 0;
	94	fAngleP = 0.0;
	95	fAngleN = 0.0;
58005f18	96	}
ac74f489	97	//______________________________________________________________________
ac74f489	98	AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
4024ebf6	99	////////////////////////////////////////////////////////////////////////
	100	// copy constructor
	101	////////////////////////////////////////////////////////////////////////
8253cd9a	102	Int_t i;
4024ebf6	103
8253cd9a	104	if(this == &source) return;
93a31784	105	this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
8253cd9a	106	this->fNp = source.fNp;
	107	this->fNn = source.fNn;
	108	delete fLowEdgeP;
	109	delete fLowEdgeN;
	110	this->fAngleP = source.fAngleP;
	111	this->fAngleN = source.fAngleN;
	112	fLowEdgeP = new Float_t[fNp];
	113	fLowEdgeN = new Float_t[fNn];
	114	for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
	115	for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
4024ebf6	116	return;
	117	}
	118
	119	AliITSgeomSSD& AliITSgeomSSD::operator=(const AliITSgeomSSD &source) {
	120	////////////////////////////////////////////////////////////////////////
	121	// assignment operator
	122	////////////////////////////////////////////////////////////////////////
8253cd9a	123	Int_t i;
4024ebf6	124
8253cd9a	125	if(this == &source) return *this;
93a31784	126	this->fShapeSSD = new TBRIK(*(source.fShapeSSD));
8253cd9a	127	this->fNp = source.fNp;
	128	this->fNn = source.fNn;
	129	delete fLowEdgeP;
	130	delete fLowEdgeN;
	131	this->fAngleP = source.fAngleP;
	132	this->fAngleN = source.fAngleN;
	133	fLowEdgeP = new Float_t[fNp];
	134	fLowEdgeN = new Float_t[fNn];
	135	for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
	136	for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
4024ebf6	137	return *this;
4024ebf6	138	}
8253cd9a	139	//______________________________________________________________________
8253cd9a	140	void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
85f1e34a	141	// Given a GEANT detector local coordinate, cm, this function returns
	142	// the detector specific P and N side strip numbers.
	143	// Inputs are:
	144	// Float_t x Geant detector local x coordinate in cm
	145	// Float_t z Geant detector local z coordinate in cm
	146	// outputs are:
	147	// Int_t &a Detector anode strip number (P side)
	148	// Int_t &c Detector cathode strip number (N side)
8253cd9a	149	Float_t d,b;
	150	Int_t i;
	151
	152	// project on to bonding edges.
	153	d = xTMath::Cos(fAngleP)+zTMath::Sin(fAngleP);
	154	b = xTMath::Cos(fAngleN)+zTMath::Sin(fAngleN);
	155	if(d<fLowEdgeP[0]) i=-1;
	156	else for(i=0;i<fNp;i++){
	157	if(fLowEdgeP[i]<d) break;
	158	} // end for i
	159	a = i;
	160	if(b<fLowEdgeN[0]) i=-1;
	161	else for(i=0;i<fNn;i++){
	162	if(fLowEdgeN[i]<b) break;
	163	} // end for i
	164	c = i;
	165	return;
	166	}
	167	//______________________________________________________________________
	168	void AliITSgeomSSD::Det2Local(Int_t a,Int_t c,Float_t &x,Float_t &z){
	169	// Float_t d,b;
	170	// Int_t i;
ac74f489	171	// use AliITSsegmentationSSD.
4024ebf6	172
ac74f489	173	x=a;
	174	z=c;
	175	Error("Det2Locat","Use AliITSsegmentationSSD");
8253cd9a	176	return;
	177	}
	178	//______________________________________________________________________
31b8cd63	179	void AliITSgeomSSD::Print(ostream *os) const {
8253cd9a	180	////////////////////////////////////////////////////////////////////////
	181	// Standard output format for this class.
	182	////////////////////////////////////////////////////////////////////////
8253cd9a	183	Int_t i;
431a7819	184	#if defined __GNUC__
	185	#if __GNUC__ > 2
	186	ios::fmtflags fmt;
	187	#else
	188	Int_t fmt;
	189	#endif
94831058	190	#else
31673006	191	#if defined __ICC \|\| defined __ECC \|\| defined _xlc_
94831058	192	ios::fmtflags fmt;
431a7819	193	#else
431a7819	194	Int_t fmt;
94831058	195	#endif
431a7819	196	#endif
8253cd9a	197
	198	fmt = os->setf(ios::scientific); // set scientific floating point output
	199	*os << "TBRIK" << " ";
	200	*os << setprecision(16) << GetDx() << " ";
	201	*os << setprecision(16) << GetDy() << " ";
	202	*os << setprecision(16) << GetDz() << " ";
	203	*os << fNp << " " << fNn << " ";
	204	*os << setprecision(16) << fAngleP << " ";
	205	*os << setprecision(16) << fAngleN << " ";
	206	for(i=0;i<fNp;i++) *os << setprecision(16) << fLowEdgeP[i] << " ";
	207	for(i=0;i<fNn;i++) *os << setprecision(16) << fLowEdgeN[i] << " ";
	208	*os << endl;
	209	os->flags(fmt); // reset back to old formating.
	210	return;
	211	}
	212	//______________________________________________________________________
	213	void AliITSgeomSSD::Read(istream *is){
	214	////////////////////////////////////////////////////////////////////////
	215	// Standard input format for this class.
	216	////////////////////////////////////////////////////////////////////////
	217	Float_t dx,dy,dz;
	218	Int_t i;
	219	char shp[20];
4024ebf6	220
8253cd9a	221	*is >> shp;
	222	*is >> dx >> dy >> dz;
	223	if(fShapeSSD!=0) delete fShapeSSD;
	224	fShapeSSD = new TBRIK("ActiveSSD","Active volume of SSD","SSD SI DET",
	225	dx,dy,dz);
	226	*is >> fNp >> fNn;
	227	*is >> fAngleP >> fAngleN;
	228	if(fLowEdgeP !=0) delete fLowEdgeP;
	229	if(fLowEdgeN !=0) delete fLowEdgeN;
	230	fLowEdgeP = new Float_t[fNp];
	231	fLowEdgeN = new Float_t[fNn];
31b8cd63	232	for(i=0;i<fNp;i++) *is >> fLowEdgeP[i];
8253cd9a	233	for(i=0;i<fNn;i++) *is >> fLowEdgeN[i];
	234	return;
	235	}
	236	//----------------------------------------------------------------------
	237	ostream &operator<<(ostream &os,AliITSgeomSSD &p){
	238	////////////////////////////////////////////////////////////////////////
	239	// Standard output streaming function.
	240	////////////////////////////////////////////////////////////////////////
4024ebf6	241
8253cd9a	242	p.Print(&os);
	243	return os;
	244	}
	245	//----------------------------------------------------------------------
	246	istream &operator>>(istream &is,AliITSgeomSSD &r){
	247	////////////////////////////////////////////////////////////////////////
	248	// Standard input streaming function.
	249	////////////////////////////////////////////////////////////////////////
4024ebf6	250
8253cd9a	251	r.Read(&is);
	252	return is;
	253	}
	254	//======================================================================
4024ebf6	255
8253cd9a	256	ClassImp(AliITSgeomSSD175)
4024ebf6	257
8253cd9a	258	AliITSgeomSSD175::AliITSgeomSSD175() : AliITSgeomSSD(){
	259	////////////////////////////////////////////////////////////////////////
	260	// default constructor
	261	////////////////////////////////////////////////////////////////////////
	262	const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
	263	// Size of sensitive detector area x,y(thickness),z
	264	const Float_t kangle = 0.0175; // angle in rad. of anode and cathodes
	265	const Float_t kpitch = 0.0095;// cm anode separation.
	266	const Int_t kNstrips = 768; // number of anode or cathode strips.
	267	Float_t leA,leC; // array of low edges anode and cathorde.
	268	Int_t i;
	269
	270	leA = new Float_t[kNstrips+1];
	271	leC = new Float_t[kNstrips+1];
	272	leA[0] = -kDxyz[0];
	273	leA[1] = -kpitch(0.5kNstrips-1);
	274	leC[0] = kDxyz[0];
	275	leC[1] = kpitch(0.5kNstrips-1);
	276	for(i=1;i<kNstrips;i++){
	277	leA[i+1] = leA[i] + kpitch;
	278	leC[i+1] = leC[i] - kpitch;
	279	} // end for i
	280	leA[kNstrips] = kDxyz[0];
	281	leC[kNstrips] = -kDxyz[0];
	282	// cout << "AliITSgeomSSD175 default creator called: start" << endl;
31b8cd63	283	AliITSgeomSSD::ResetSSD(kDxyz,kangle,-kangle,
8253cd9a	284	kNstrips+1,leA,kNstrips+1,leC);
	285	delete leA;
	286	delete leC;
	287	// cout << "AliITSgeomSSD175 default creator called: end" << endl;
	288	}
	289	//________________________________________________________________________
	290	ostream &operator<<(ostream &os,AliITSgeomSSD175 &p){
	291	////////////////////////////////////////////////////////////////////////
	292	// Standard output streaming function.
	293	////////////////////////////////////////////////////////////////////////
4024ebf6	294
8253cd9a	295	p.Print(&os);
	296	return os;
	297	}
	298	//----------------------------------------------------------------------
	299	istream &operator>>(istream &is,AliITSgeomSSD175 &r){
	300	////////////////////////////////////////////////////////////////////////
	301	// Standard input streaming function.
	302	////////////////////////////////////////////////////////////////////////
4024ebf6	303
8253cd9a	304	r.Read(&is);
	305	return is;
	306	}
	307	//======================================================================
4024ebf6	308
8253cd9a	309	ClassImp(AliITSgeomSSD275and75)
4024ebf6	310
8253cd9a	311	AliITSgeomSSD275and75::AliITSgeomSSD275and75() : AliITSgeomSSD(){
	312	////////////////////////////////////////////////////////////////////////
	313	// default constructor
	314	////////////////////////////////////////////////////////////////////////
e99dbc71	315	}
	316	//----------------------------------------------------------------------
	317	AliITSgeomSSD275and75::AliITSgeomSSD275and75(Int_t npar,Float_t *par) :
	318	AliITSgeomSSD(){
85f1e34a	319	// Default constructor for AliITSgeomSSD with strip angles of
	320	// 275 miliradians and 75 miliradians. This constructor initlizes
	321	// AliITSgeomSSD with the correct values. This is the miror image
	322	// of the AliITSgeomSSD75and275 class.
8253cd9a	323	const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
	324	// Size of sensitive detector area x,y(thickness),z
	325	const Float_t kangleA = 0.0275; // angle in rad. of anode and cathodes
	326	const Float_t kangleC = 0.0075; // angle in rad. of anode and cathodes
	327	const Float_t kpitch = 0.0095;// cm anode separation.
	328	const Int_t kNstrips = 768; // number of anode or cathode strips.
	329	Float_t leA,leC; // array of low edges anode and cathorde.
	330	Int_t i;
	331
ac74f489	332	if(npar<3){
	333	Error("AliITSgeomSSD275and75",
	334	"npar=%d<3. array par must be [3] or larger.",npar);
	335	return;
	336	} // end if
8253cd9a	337	leA = new Float_t[kNstrips+1];
	338	leC = new Float_t[kNstrips+1];
	339	leA[0] = -kDxyz[0];
	340	leA[1] = -kpitch(0.5kNstrips-1);
	341	leC[0] = kDxyz[0];
	342	leC[1] = kpitch(0.5kNstrips-1);
	343	for(i=1;i<kNstrips;i++){
	344	leA[i+1] = leA[i] + kpitch;
	345	leC[i+1] = leC[i] - kpitch;
	346	} // end for i
	347	leA[kNstrips] = kDxyz[0];
	348	leC[kNstrips] = -kDxyz[0];
	349	// cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
e99dbc71	350	AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
8253cd9a	351	kNstrips+1,leA,kNstrips+1,leC);
68ec3d3d	352	delete [] leA;
68ec3d3d	353	delete [] leC;
8253cd9a	354	// cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
	355	}
	356	//________________________________________________________________________
	357	ostream &operator<<(ostream &os,AliITSgeomSSD275and75 &p){
	358	////////////////////////////////////////////////////////////////////////
	359	// Standard output streaming function.
	360	////////////////////////////////////////////////////////////////////////
4024ebf6	361
8253cd9a	362	p.Print(&os);
	363	return os;
	364	}
	365	//----------------------------------------------------------------------
	366	istream &operator>>(istream &is,AliITSgeomSSD275and75 &r){
	367	////////////////////////////////////////////////////////////////////////
	368	// Standard input streaming function.
	369	////////////////////////////////////////////////////////////////////////
4024ebf6	370
8253cd9a	371	r.Read(&is);
	372	return is;
	373	}
	374	//======================================================================
4024ebf6	375
8253cd9a	376	ClassImp(AliITSgeomSSD75and275)
4024ebf6	377
8253cd9a	378	AliITSgeomSSD75and275::AliITSgeomSSD75and275() : AliITSgeomSSD(){
	379	////////////////////////////////////////////////////////////////////////
	380	// default constructor
	381	////////////////////////////////////////////////////////////////////////
e99dbc71	382	}
	383	AliITSgeomSSD75and275::AliITSgeomSSD75and275(Int_t npar,Float_t *par) :
	384	AliITSgeomSSD(){
85f1e34a	385	// Default constructor for AliITSgeomSSD with strip angles of
	386	// 75 miliradians and 275 miliradians. This constructor initlizes
	387	// AliITSgeomSSD with the correct values. This is the miror image
	388	// of the AliITSgeomSSD275and75 class.
8253cd9a	389	const Float_t kDxyz[] ={3.6500,0.0150,2.000};//cm. (Geant 3.12 units)
	390	// Size of sensitive detector area x,y(thickness),z
	391	const Float_t kangleA = 0.0075; // angle in rad. of anode and cathodes
	392	const Float_t kangleC = 0.0275; // angle in rad. of anode and cathodes
	393	const Float_t kpitch = 0.0095;// cm anode separation.
	394	const Int_t kNstrips = 768; // number of anode or cathode strips.
	395	Float_t leA,leC; // array of low edges anode and cathorde.
	396	Int_t i;
	397
ac74f489	398	if(npar<3){
	399	Error("AliITSgeomSSD75and275",
	400	"npar=%d<3. array par must be [3] or larger.",npar);
	401	return;
	402	} // end if
8253cd9a	403	leA = new Float_t[kNstrips+1];
	404	leC = new Float_t[kNstrips+1];
	405	leA[0] = -kDxyz[0];
	406	leA[1] = -kpitch(0.5kNstrips-1);
	407	leC[0] = kDxyz[0];
	408	leC[1] = kpitch(0.5kNstrips-1);
	409	for(i=1;i<kNstrips;i++){
	410	leA[i+1] = leA[i] + kpitch;
	411	leC[i+1] = leC[i] - kpitch;
	412	} // end for i
	413	leA[kNstrips] = kDxyz[0];
	414	leC[kNstrips] = -kDxyz[0];
	415	// cout << "AliITSgeomSSD275and75 default creator called: start" << endl;
e99dbc71	416	AliITSgeomSSD::ResetSSD(par,kangleA,kangleC,
8253cd9a	417	kNstrips+1,leA,kNstrips+1,leC);
	418	delete leA;
	419	delete leC;
	420	// cout << "AliITSgeomSSD275and75 default creator called: end" << endl;
	421	}
	422	//________________________________________________________________________
	423	ostream &operator<<(ostream &os,AliITSgeomSSD75and275 &p){
	424	////////////////////////////////////////////////////////////////////////
	425	// Standard output streaming function.
	426	////////////////////////////////////////////////////////////////////////
4024ebf6	427
8253cd9a	428	p.Print(&os);
	429	return os;
	430	}
	431	//----------------------------------------------------------------------
	432	istream &operator>>(istream &is,AliITSgeomSSD75and275 &r){
	433	////////////////////////////////////////////////////////////////////////
	434	// Standard input streaming function.
	435	////////////////////////////////////////////////////////////////////////
4024ebf6	436
8253cd9a	437	r.Read(&is);
	438	return is;
	439	}
	440	//======================================================================