X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=ITS%2FAliITSvSDD03.cxx;h=550f00e687abbb1e64790373f051055700ae6605;hb=d41276fc746c7d26a19d90c0565b2da05e82023d;hp=96675966cc0bb95fca64af4f908166708f24b449;hpb=8ba39da91cc548b1300a6fffdca0a2199d0eb8ef;p=u%2Fmrichter%2FAliRoot.git

diff --git a/ITS/AliITSvSDD03.cxx b/ITS/AliITSvSDD03.cxx
index 96675966cc0..550f00e687a 100644
--- a/ITS/AliITSvSDD03.cxx
+++ b/ITS/AliITSvSDD03.cxx
@@ -27,11 +27,11 @@
 #include <TBRIK.h>
 #include <TLorentzVector.h>
 #include <TVirtualMC.h>
+#include <TGeoMatrix.h>
 
 #include "AliMC.h"
 #include "AliRun.h"
 #include "AliMagF.h"
-#include "AliITSGeant3Geometry.h"
 #include "AliTrackReference.h"
 #include "AliITShit.h"
 #include "AliITS.h"
@@ -40,13 +40,13 @@
 #include "AliITSgeomSDD.h"
 #include "AliITSgeomSSD.h"
 #include "AliITSDetTypeSim.h"
-#include "AliITSresponseSPD.h"
-#include "AliITSresponseSDD.h"
-#include "AliITSresponseSSD.h"
+#include "AliITSCalibrationSPD.h"
+#include "AliITSCalibrationSDD.h"
+#include "AliITSCalibrationSSD.h"
 #include "AliITSsegmentationSPD.h"
 #include "AliITSsegmentationSDD.h"
 #include "AliITSsegmentationSSD.h"
-#include "AliITSsimulationSPDdubna.h"
+#include "AliITSsimulationSPD.h"
 #include "AliITSsimulationSDD.h"
 #include "AliITSsimulationSSD.h"
 
@@ -139,38 +139,6 @@ fYear(2003){
     strncpy(fWrite,fEuclidGeomDet,60);
 }
 //______________________________________________________________________
-AliITSvSDD03::AliITSvSDD03(const AliITSvSDD03 &source) :  AliITS(source){
-    ////////////////////////////////////////////////////////////////////////
-    //     Copy Constructor for ITS SDD test beam 2002 version 1.
-    // This class is not to be copied. Function only dummy.
-    // Inputs:
-    //    const AliITSvSDD03 &source   The class to be copied
-    // Outputs:
-    //    none.
-    // Return:
-    //    A warning message.
-    ////////////////////////////////////////////////////////////////////////
-    if(&source == this) return;
-    Warning("Copy Constructor","Not allowed to copy AliITSvSDD03");
-    return;
-}
-//______________________________________________________________________
-AliITSvSDD03& AliITSvSDD03::operator=(const AliITSvSDD03 &source){
-    ////////////////////////////////////////////////////////////////////////
-    //    Assignment operator for the ITS SDD test beam 2002 version 1.
-    // This class is not to be copied. Function only dummy.
-    // Inputs:
-    //    const AliITSvSDD03 &source   The class to be copied
-    // Outputs:
-    //    none.
-    // Return:
-    //    A Warning message
-    ////////////////////////////////////////////////////////////////////////
-    if(&source == this) return *this;
-    Warning("= operator","Not allowed to copy AliITSvSDD03");
-    return *this;
-}
-//______________________________________________________________________
 AliITSvSDD03::~AliITSvSDD03() {
     ////////////////////////////////////////////////////////////////////////
     //    Standard destructor for the ITS SDD test beam 2002 version 1.
@@ -531,7 +499,7 @@ void AliITSvSDD03::CreateMaterials(){
     // Monte Carlo simulations for the geometries AliITSv1, AliITSv3,
     // AliITSvSDD03.
     // In general it is automatically replaced by
-    // the CreatMaterials routine defined in AliITSv?. Should the function
+    // the CreateMaterials routine defined in AliITSv?. Should the function
     // CreateMaterials not exist for the geometry version you are using this
     // one is used. See the definition found in AliITSv5 or the other routine
     // for a complete definition.
@@ -708,96 +676,65 @@ void AliITSvSDD03::InitAliITSgeom(){
     //    none.
     // Return:
     //    none.
+    const Int_t knlayers=12;
+    //   const Int_t kndeep=6;
+    const Int_t kltypess=2;
+    const AliITSDetector kidet[knlayers]={kSSD,kSDD};
+    const TString knames[kltypess]={
+        "/ALIC_1/ITSV_1/ITEL_%d/ITAI_1/IMB0_1/IMBS_1",
+        "/ALIC_1/ITSV_1/IDET_%d/IDAI_1/ITS0_1/ITST_1"};
+    const Int_t kitsGeomTreeCopys[kltypess]={10,2};
+    const Int_t knp=384;
+    const Float_t kpitch=50.E-4;/*cm*/
+    Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
+    Int_t nlad[knlayers]={knlayers*1};
+    Int_t ndet[knlayers]={knlayers*1};
+    Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
+    TString path,shapeName;
+    TGeoHMatrix matrix;
+    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
+    TArrayD shapePar;
+    TArrayF shapeParF;
+    Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
+    AliITSgeom *geom = new AliITSgeom(0,knlayers,nlad,ndet,mod);
+    if(GetITSgeom()!=0) SetITSgeom(0x0);// delet existing if there.
+    SetITSgeom(geom);
 
-  
-  if(strcmp(gMC->GetName(),"TGeant3")) {
-    Error("InitAliITSgeom",
-	  "Wrong Monte Carlo. InitAliITSgeom uses TGeant3 calls");
+    p[0]=-box[0];
+    n[0]=box[0];
+    // Fill in anode and cathode strip locations (lower edge)
+    for(i=1;i<knp;i++){
+        p[i] =p[i-1]+kpitch;
+        n[i] =n[i-1]-kpitch;
+    } // end for i
+    p[knp]=box[0];
+    n[knp]=-box[0];
+    for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
+        mod = DecodeDetector(fIdSens[i],cp0,lay,lad,det);
+        path.Form(knames[i].Data(),cp0);
+        gMC->GetTransformation(path.Data(),matrix);
+        gMC->GetShape(path.Data(),shapeName,shapePar);
+        shapeParF.Set(shapePar.GetSize());
+        for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
+        geom->CreateMatrix(mod,lay,lad,det,kidet[i],trans,rot);
+        geom->SetTrans(mod,matrix.GetTranslation());
+        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
+        geom->GetGeomMatrix(mod)->SetPath(path.Data());
+        switch (kidet[i]){
+        case kSDD: if(!(GetITSgeom()->IsShapeDefined((Int_t)kSDD))){
+            geom->ReSetShape(kSDD,new AliITSgeomSDD256(shapeParF.GetSize(),
+                                                       shapeParF.GetArray()));
+            isShapeDefined[i]=kTRUE;
+        } break;
+        case kSSD:if(!(GetITSgeom()->IsShapeDefined((Int_t)kSSD))){
+            geom->ReSetShape(kSSD,new AliITSgeomSSD(box,0.0,0.0,
+                                                    knp+1,p,knp+1,n));
+            isShapeDefined[i]=kTRUE;
+        } break;
+        default:{} break;
+        } // end switch
+    } // end for i,cp0
     return;
-  } // end if
-  Info("InitAliITSgeom","Reading geometry transformation directly from Geant 3");
-  const Int_t knp=384;
-  const Float_t kpitch=50.E-4;/*cm*/
-  Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
-  const Int_t kltypess = 2;
-  const Int_t knlayers = 12;
-  const Int_t kndeep = 6;
-  Int_t itsGeomTreeNames[kltypess][kndeep],lnam[20],lnum[20];
-  Int_t nlad[knlayers],ndet[knlayers];
-  Double_t t[3],r[10];
-  Float_t  par[20],att[20];
-  Int_t    npar,natt,idshape,imat,imed,id;
-  AliITSGeant3Geometry *ig = new AliITSGeant3Geometry();
-  Int_t mod,typ,lay,lad,det,cpy,i,j,k;
-  Char_t names[kltypess][kndeep][4];
-  Int_t itsGeomTreeCopys[kltypess][kndeep];
-  Char_t *namesA[kltypess][kndeep] = {
-    {"ALIC","ITSV","ITEL","ITAI","IMB0","IMBS"}, 
-    {"ALIC","ITSV","IDET","IDAI","ITS0","ITST"}};
-  Int_t itsGeomTreeCopysA[kltypess][kndeep]= {{1,1,10,1,1,1},
-					    {1,1,2,1,1,1}};
-  for(i=0;i<kltypess;i++)for(j=0;j<kndeep;j++){
-    for(k=0;k<4;k++) names[i][j][k] = namesA[i][j][k];
-    itsGeomTreeCopys[i][j] = itsGeomTreeCopysA[i][j];
-  } // end for i,j
-  p[0]=-box[0];
-  n[0]=box[0];
-  for(i=1;i<knp;i++){// Fill in anode and cathode strip locations (lower edge)
-    p[i] =p[i-1]+kpitch;
-    n[i] =n[i-1]-kpitch;
-  } // end for i
-  p[knp+1]=box[0];
-  n[knp+1]=-box[0];
-
-  for(i=0;i<20;i++) lnam[i] = lnum[i] = 0;
-  for(i=0;i<kltypess;i++)for(j=0;j<kndeep;j++) 
-    strncpy((char*) &itsGeomTreeNames[i][j],names[i][j],4);
-  //	itsGeomTreeNames[i][j] = ig->StringToInt(names[i][j]);
-  mod = knlayers;
-  if(GetITSgeom()!=0) SetITSgeom(0x0);
-  for(Int_t iMod=0; iMod<knlayers; iMod++){
-    nlad[iMod]=1; ndet[iMod]=1;
-  }
-  
-  AliITSgeom* geom = new AliITSgeom(0,knlayers,nlad,ndet,mod);
-  SetITSgeom(geom);
-  fIdSens[0] = 0; fIdSens[1] = 1; // Properly reset in Init later.
-  for(typ=1;typ<=kltypess;typ++){
-    for(j=0;j<kndeep;j++) lnam[j] = itsGeomTreeNames[typ-1][j];
-    for(j=0;j<kndeep;j++) lnum[j] = itsGeomTreeCopys[typ-1][j];
-    if(typ == 1) id = fIdSens[0];
-    else id = fIdSens[1];
-    lad = 1;
-    det = 1;
-    for(cpy=1;cpy<=itsGeomTreeCopys[typ-1][2];cpy++){
-      mod = DecodeDetector(id,cpy,lay,lad,det);
-      //lunm[2] is the copy number, from 1 to 10 for SSD
-      // 1,2 for SDD, depending on the module number
-      if(mod<=3) lnum[2]=mod+1;
-      if(mod>=6) lnum[2]=mod-1;
-      if(mod==4) lnum[2]=1;
-      if(mod==5) lnum[2]=2;
-      ig->GetGeometry(kndeep,lnam,lnum,t,r,idshape,npar,natt,par,att,
-		      imat,imed);
-
-      switch (typ){
-      case 2:
-	GetITSgeom()->CreatMatrix(mod,lay,lad,det,kSDD,t,r);
-	if(!(GetITSgeom()->IsShapeDefined((Int_t)kSDD))){
-	  GetITSgeom()->ReSetShape(kSDD,new AliITSgeomSDD256(npar,par));
-	} // end if
-	break;
-      case 1:
-	GetITSgeom()->CreatMatrix(mod,lay,lad,det,kSSD,t,r);
-	if(!(GetITSgeom()->IsShapeDefined((Int_t)kSSD))){
-	  GetITSgeom()->ReSetShape(kSSD,new AliITSgeomSSD(box,0.0,0.0,
-						      knp+1,p,knp+1,n));
-	} // end if
-	break;
-      } // end switch
-    } // end for cpy
-  } // end for typ
-  return;
 }
 //______________________________________________________________________
 void AliITSvSDD03::Init(){
@@ -836,33 +773,32 @@ void AliITSvSDD03::SetDefaults(){
     // Return:
     //    none.
 
-    const Float_t kconv = 1.0e+04; // convert cm to microns
+  //    const Float_t kconv = 1.0e+04; // convert cm to microns
 
     if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
     fDetTypeSim->SetITSgeom(GetITSgeom());
-    fDetTypeSim->ResetResponse();
+    fDetTypeSim->ResetCalibrationArray();
     fDetTypeSim->ResetSegmentation();
  
     AliITSgeomSDD *s1;
     AliITSgeomSSD *s2;
-    SetResponseModel(GetITSgeom()->GetStartSPD(),new AliITSresponseSPD());
-    SetSegmentationModel(kSPD,new AliITSsegmentationSPD());
+    SetCalibrationModel(GetITSgeom()->GetStartSPD(),new AliITSCalibrationSPD());
+    SetSegmentationModel(kSPD,(AliITSsegmentationSPD*)
+			 (GetITSgeom()->GetShape(kSPD)));
     fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigitSPD");
 
     // SDD
     s1 = (AliITSgeomSDD*) GetITSgeom()->GetShape(kSDD);// Get shape info. Do it this way for now.
-    AliITSresponseSDD *resp1=new AliITSresponseSDD("simulated");
-    SetResponseModel(GetITSgeom()->GetStartSDD(),resp1);
-
-    AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(GetITSgeom(),resp1);
-    seg1->SetDetSize(s1->GetDx()*kconv, // base this on AliITSgeomSDD
-		     s1->GetDz()*2.*kconv, // for now.
-		     s1->GetDy()*2.*kconv); // x,z,y full width in microns.
+    AliITSCalibrationSDD *resp1=new AliITSCalibrationSDD("simulated");
+    SetCalibrationModel(GetITSgeom()->GetStartSDD(),resp1);
 
+    AliITSsegmentationSDD *seg1 = (AliITSsegmentationSDD*)
+			 (GetITSgeom()->GetShape(kSDD));
+    seg1->SetDriftSpeed(resp1->GetDriftSpeed());
     seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
     SetSegmentationModel(kSDD,seg1);
-    const char *kData1=(fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSDD()))->DataType();
-    const char *kopt=fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSDD())->ZeroSuppOption();
+    const char *kData1=(fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSDD()))->DataType();
+    const char *kopt=resp1->GetZeroSuppOption();
     if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
 	fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigit");
     } else fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigitSDD");
@@ -871,13 +807,11 @@ void AliITSvSDD03::SetDefaults(){
 
     s2 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);// Get shape info. Do it this way for now.
    
-    AliITSresponse *resp2= new AliITSresponseSSD("simulated");
-    SetResponseModel(GetITSgeom()->GetStartSSD(),resp2);
+    AliITSCalibration *resp2= new AliITSCalibrationSSD("simulated");
+    SetCalibrationModel(GetITSgeom()->GetStartSSD(),resp2);
 
-    AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(GetITSgeom());
-    seg2->SetDetSize(s2->GetDx()*2.*kconv, // base this on AliITSgeomSSD
-		     s2->GetDz()*2.*kconv, // for now.
-		     s2->GetDy()*2.*kconv); // x,z,y full width in microns.
+    AliITSsegmentationSSD *seg2 = (AliITSsegmentationSSD*)
+			 (GetITSgeom()->GetShape(kSSD));
     seg2->SetPadSize(50.,0.); // strip x pitch in microns
     seg2->SetNPads(384,0); // number of strips on each side.
     seg2->SetLayer(5);
@@ -886,7 +820,7 @@ void AliITSvSDD03::SetDefaults(){
     seg2->SetAnglesLay6(0.,0.); // strip angles rad P and N side.
 
     SetSegmentationModel(kSSD,seg2); 
-    const char *kData2=(fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSSD()))->DataType();
+    const char *kData2=(fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSSD()))->DataType();
     if(strstr(kData2,"real") ) fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigit");
     else fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigitSSD");
 
@@ -909,20 +843,20 @@ void AliITSvSDD03::SetDefaultSimulation(){
   if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
   AliITSsimulation *sim;
   //AliITSsegmentation *seg;
-  //AliITSresponse *res;
+  //AliITSCalibration *res;
   //SPD
   if(fDetTypeSim){
     sim = fDetTypeSim->GetSimulationModel(kSPD);
     if (!sim) {
       //seg =(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSPD);
       //if(seg==0) seg = new AliITSsegmentationSPD();
-      //res = (AliITSresponse*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSPD());
-      //if(res==0) res = new AliITSresponseSPD();
-      sim = new AliITSsimulationSPDdubna(fDetTypeSim);
+      //res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSPD());
+      //if(res==0) res = new AliITSCalibrationSPD();
+      sim = new AliITSsimulationSPD(fDetTypeSim);
       SetSimulationModel(kSPD,sim);
     }else{ // simulation exists, make sure it is set up properly.
       sim->SetSegmentationModel(kSPD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSPD));
-      sim->SetResponseModel(GetITSgeom()->GetStartSPD(),(AliITSresponse*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSPD()));
+      sim->SetCalibrationModel(GetITSgeom()->GetStartSPD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSPD()));
       sim->Init();
     } // end if
   } // end if iDetType
@@ -931,12 +865,12 @@ void AliITSvSDD03::SetDefaultSimulation(){
     sim = fDetTypeSim->GetSimulationModel(kSDD);
     if (!sim) {
       //      seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSDD);
-      //res = (AliITSresponse*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSDD());
+      //res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSDD());
       sim = new AliITSsimulationSDD(fDetTypeSim);
       SetSimulationModel(kSDD,sim);
     }else{ // simulation exists, make sure it is set up properly.
       sim->SetSegmentationModel(kSDD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSDD));
-      sim->SetResponseModel(GetITSgeom()->GetStartSDD(),(AliITSresponse*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSDD()));
+      sim->SetCalibrationModel(GetITSgeom()->GetStartSDD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSDD()));
       
       sim->Init();
     } //end if
@@ -946,12 +880,12 @@ void AliITSvSDD03::SetDefaultSimulation(){
     sim = fDetTypeSim->GetSimulationModel(kSSD);
     if (!sim) {
       //      seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSSD);
-      // res = (AliITSresponse*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSSD());
+      // res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSSD());
       sim = new AliITSsimulationSSD(fDetTypeSim);
       SetSimulationModel(kSSD,sim);
     }else{ // simulation exists, make sure it is set up properly.
       sim->SetSegmentationModel(kSSD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSSD));
-      sim->SetResponseModel(GetITSgeom()->GetStartSSD(),(AliITSresponse*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSSD()));
+      sim->SetCalibrationModel(GetITSgeom()->GetStartSSD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSSD()));
       sim->Init();
     } // end if
   } // end if iDetType