{
//////////////////////////////////////////////////////
//
// ALIGNMENT.C:
//
// Root macro performing alignment constants
// analysis. For misalignment studies purpose only.
//
// This Macro is for the Velo Alignment WebPage
// It is intended to use it with perfectly aligned events
// but easy to extend to misaligned ones
//
// S.V. 05/09/06
//
//////////////////////////////////////////////////////

//
//Initialization
//

gROOT->Reset();

//   
// Initialization of histograms
//


// For internal alignment

TH2F *R_tx = new TH2F("R_tx","",129,-1.,22.,100,-0.10,0.10);
TH2F *L_tx = new TH2F("L_tx","",129,-1.,22.,100,-0.10,0.10);
TH2F *R_ty = new TH2F("R_ty","",129,-1.,22.,100,-0.10,0.10);
TH2F *L_ty = new TH2F("L_ty","",129,-1.,22.,100,-0.10,0.10);
TH2F *R_tz = new TH2F("R_tz","",129,-1.,22.,100,-0.10,0.10);
TH2F *L_tz = new TH2F("L_tz","",129,-1.,22.,100,-0.10,0.10);
TH2F *R_rx = new TH2F("R_rx","",129,-1.,22.,100,-0.008,0.008);
TH2F *L_rx = new TH2F("L_rx","",129,-1.,22.,100,-0.008,0.008);
TH2F *R_ry = new TH2F("R_ry","",129,-1.,22.,100,-0.008,0.008);
TH2F *L_ry = new TH2F("L_ry","",129,-1.,22.,100,-0.008,0.008);
TH2F *R_rz = new TH2F("R_rz","",129,-1.,22.,100,-0.008,0.008);
TH2F *L_rz = new TH2F("L_rz","",129,-1.,22.,100,-0.008,0.008);


TH2F *compR_tx = new TH2F("compR_tx","",129,-1.,22.,100,-0.10,0.10);
TH2F *compL_tx = new TH2F("compL_tx","",129,-1.,22.,100,-0.10,0.10);
TH2F *compR_ty = new TH2F("compR_ty","",129,-1.,22.,100,-0.10,0.10);
TH2F *compL_ty = new TH2F("compL_ty","",129,-1.,22.,100,-0.10,0.10);
TH2F *compR_tz = new TH2F("compR_tz","",129,-1.,22.,100,-0.10,0.10);
TH2F *compL_tz = new TH2F("compL_tz","",129,-1.,22.,100,-0.10,0.10);
TH2F *compR_rx = new TH2F("compR_rx","",129,-1.,22.,100,-0.008,0.008);
TH2F *compL_rx = new TH2F("compL_rx","",129,-1.,22.,100,-0.008,0.008);
TH2F *compR_ry = new TH2F("compR_ry","",129,-1.,22.,100,-0.008,0.008);
TH2F *compL_ry = new TH2F("compL_ry","",129,-1.,22.,100,-0.008,0.008);
TH2F *compR_rz = new TH2F("compR_rz","",129,-1.,22.,100,-0.008,0.008);
TH2F *compL_rz = new TH2F("compL_rz","",129,-1.,22.,100,-0.008,0.008);


TH2F *scatR_tx = new TH2F("scatR_tx","",100,-0.1,0.1,100,-0.10,0.10);
TH2F *scatL_tx = new TH2F("scatL_tx","",100,-0.1,0.1,100,-0.10,0.10);
TH2F *scatR_ty = new TH2F("scatR_ty","",100,-0.1,0.1,100,-0.10,0.10);
TH2F *scatL_ty = new TH2F("scatL_ty","",100,-0.1,0.1,100,-0.10,0.10);
TH2F *scatR_tz = new TH2F("scatR_tz","",100,-0.1,0.1,100,-0.10,0.10);
TH2F *scatL_tz = new TH2F("scatL_tz","",100,-0.1,0.1,100,-0.10,0.10);
TH2F *scatR_rx = new TH2F("scatR_rx","",100,-0.008,0.008,100,-0.008,0.008);
TH2F *scatL_rx = new TH2F("scatL_rx","",100,-0.008,0.008,100,-0.008,0.008);
TH2F *scatR_ry = new TH2F("scatR_ry","",100,-0.008,0.008,100,-0.008,0.008);
TH2F *scatL_ry = new TH2F("scatL_ry","",100,-0.008,0.008,100,-0.008,0.008);
TH2F *scatR_rz = new TH2F("scatR_rz","",100,-0.008,0.008,100,-0.008,0.008);
TH2F *scatL_rz = new TH2F("scatL_rz","",100,-0.008,0.008,100,-0.008,0.008);


TH1F *compt = new TH1F("compt","",100,-0.05,0.05);
TH1F *compr = new TH1F("compr","",100,-0.005,0.005);


//
// Initialization of variables
//

char    data[80], misal[80];

bool print_info = false;  // Print some debugging information 
                          // Turn it off if looping on many files                        
// Stations taken into the alignment
int first  = 0;
int last   = 20;

// Stations you want to plot
int first_station  = 0;
int last_station  = 20;

int nplans = last-first+1;


int  n_type, n_station, n_dof;
float  n_const, n_pull;


double  biases_bef_R[150], biases_bef_L[150];
double  biases_aft_R[150], biases_aft_L[150];

double z_l[] = {-176.15, -143.85, -116.15, -83.85, -56.15, -23.85,
		3.85, 36.15, 63.85, 96.15, 123.85, 156.15,
		183.85, 216.15, 243.85, 276.15, 433.85, 586.15,
		633.85, 686.15, 733.85};

double z_r[] = {-158.85, -131.15, -98.85, -71.15, -38.85, -11.15,
		21.15, 48.85, 81.15, 108.85, 141.15, 168.85,
		201.15, 228.85, 261.15, 288.85, 451.15, 598.85,
		651.15, 698.85, 751.15};


//
// Then look the results
//


sprintf(data,  "Align.root");  // Result in our case (file 1)
//sprintf(misal,  "Align_perfect.root",k);  // The file containing the misalignments, if you're running with non-perfect geometry

  
  TFile *res = new TFile(data);
  
  TTree *rest  = (TTree*)res->Get("Align/Constants");
  
  rest->SetBranchAddress("type"      ,&n_type);
  rest->SetBranchAddress("station"   ,&n_station);
  rest->SetBranchAddress("DOF"       ,&n_dof);
  rest->SetBranchAddress("mis_value" ,&n_const);
  

  
  Int_t nentries   = rest->GetEntries();


  for (Int_t j=0; j<150; j++)
  {
    biases_bef_R[j]  = 0.0;
    biases_bef_L[j]  = 0.0;
    biases_aft_R[j]  = 0.0;
    biases_aft_L[j]  = 0.0;
  }

//
// First we get the original misalignments from the reference file
// (Here you need to replace by misal info if you look at misaligned file) 
//
  for (Int_t i=0; i<nentries; i++) 
  {       
    rest->GetEntry(i);
    
    // Left side
    if (n_type == 0 && n_station>=first && n_station<=last) 
    {
      biases_bef_L[int(n_station-first)+nplans*int(n_dof)] = n_const;
      
      if (n_dof == 1 && int(n_station)%2 == 1) biases_bef_L[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
      if (n_dof == 2 && int(n_station)%2 == 1) biases_bef_L[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
      
      if (n_dof == 5 && int(n_station)%2 == 1) biases_bef_L[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
      if (n_dof == 4 && int(n_station)%2 == 0) biases_bef_L[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
    }
    
    // Right side
    if (n_type == 1 && n_station>=first && n_station<=last) 
    {
      biases_bef_R[int(n_station-first)+nplans*int(n_dof)] = n_const;
      
      if (n_dof == 1 && int(n_station)%2 == 0) biases_bef_R[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
      if (n_dof == 2 && int(n_station)%2 == 0) biases_bef_R[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
      
      if (n_dof == 4 && int(n_station)%2 == 1) biases_bef_R[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
      if (n_dof == 5 && int(n_station)%2 == 0) biases_bef_R[int(n_station-first)+nplans*int(n_dof)]  = -n_const;
    }

    // Left side box
    if (n_type == 4 && n_station == 0) biases_bef_L[6*nplans+int(n_dof)] = n_const;

    // Right side box
    if (n_type == 4 && n_station == 1) biases_bef_R[6*nplans+int(n_dof)] = n_const;
    
  }

  double off_l_x  = biases_bef_L[6*nplans];
  double off_l_y  = biases_bef_L[6*nplans+1];
  double off_l_z  = biases_bef_L[6*nplans+2];
  double tilt_l_x = biases_bef_L[6*nplans+3];
  double tilt_l_y = biases_bef_L[6*nplans+4];
  double tilt_l_z = biases_bef_L[6*nplans+5];
  
  double off_r_x  = biases_bef_R[6*nplans];
  double off_r_y  = biases_bef_R[6*nplans+1];
  double off_r_z  = biases_bef_R[6*nplans+2];
  double tilt_r_x = biases_bef_R[6*nplans+3];
  double tilt_r_y = biases_bef_R[6*nplans+4];
  double tilt_r_z = biases_bef_R[6*nplans+5];
  
//
// Do the same operation to get the computed misalignments
//
  for (Int_t i=0; i<nentries; i++) 
  {       
    rest->GetEntry(i);

    // Left side
    if (n_type == 2 && n_station>=first && n_station<=last)
      biases_aft_L[int(n_station-first)+nplans*int(n_dof)]  = n_const;
    
    // Right side
    if (n_type == 3 && n_station>=first && n_station<=last)
      biases_aft_R[int(n_station-first)+nplans*int(n_dof)]  = n_const;
	
    // From Overlap Alignment

    if (n_type == 6 && n_station == 1)
      biases_aft_R[6*(nplans+1)+int(n_dof)] = n_const;

    // From PV alignment

    // Left box tilts 
    if (n_type == 7 && n_station == 0) 
      biases_aft_L[6*nplans+int(n_dof)] = n_const;
    
    // Right box tilts
    if (n_type == 7 && n_station == 1) 
      biases_aft_R[6*nplans+int(n_dof)] = n_const;
      
    // Left box offsets
    if (n_type == 8 && n_station == 0 && n_dof <=2) 
      biases_aft_L[6*nplans+int(n_dof)] = n_const;
    
    // Right box offsets
    if (n_type == 8 && n_station == 1 && n_dof <=2) 
      biases_aft_R[6*nplans+int(n_dof)] = n_const;
  }


// 
// The loop on data is finished, we could now play with them....
// 


//  
// Here we compute the corrected misalignments values (for the canonical approach)
// We don't change the absolute value of the misalignments introduced, we
// just rearramge them to an 'offset-free' form 
//

//  if (correct_offsets)
  {
    // Means and sigma values necessary

    double zmoy_L   = 0.0;
    double s_zmoy_L = 0.0;
    double zmoy_R   = 0.0;
    double s_zmoy_R = 0.0;
    
    for (Int_t j=first; j<=last; j++) {
      zmoy_L  += z_l[j];
      zmoy_R  += z_r[j];
    }

    zmoy_L /= nplans;
    zmoy_R /= nplans;
    
    for (Int_t j=first; j<=last; j++) {
      s_zmoy_L += (z_l[j]-zmoy_L)*(z_l[j]-zmoy_L);
      s_zmoy_R += (z_r[j]-zmoy_R)*(z_r[j]-zmoy_R);
    }

    s_zmoy_L /= nplans;
    s_zmoy_R /= nplans;
    
    // First of all, we have separated misalignments, compute the global ones
    
    for (j=0; j<nplans; j++){

      // Left

      biases_bef_L[j]          += off_l_x + tilt_l_y*z_l[j+first];
      biases_bef_L[j+nplans]   += off_l_y - tilt_l_x*z_l[j+first];
      biases_bef_L[j+2*nplans] += off_l_z;
      biases_bef_L[j+3*nplans] += tilt_l_x;
      biases_bef_L[j+4*nplans] += -tilt_l_y;
      biases_bef_L[j+5*nplans] += tilt_l_z;
      
      // Right (rotation around Z axis)
      
      biases_bef_R[j]          += -off_r_x - tilt_r_y*z_r[j+first];
      biases_bef_R[j+nplans]   += -off_r_y + tilt_r_x*z_r[j+first];
      biases_bef_R[j+2*nplans] += -off_r_z;
      biases_bef_R[j+3*nplans] += -tilt_r_x;
      biases_bef_R[j+4*nplans] += tilt_r_y;
      biases_bef_R[j+5*nplans] += tilt_r_z;      
    }

    // Reset the global coeffs
      
    biases_bef_L[6*nplans]   = 0.;
    biases_bef_L[6*nplans+1] = 0.;
    biases_bef_L[6*nplans+2] = 0.;
    biases_bef_R[6*nplans]   = 0.;
    biases_bef_R[6*nplans+1] = 0.;
    biases_bef_R[6*nplans+2] = 0.;
    
    biases_bef_L[6*nplans+3] = 0.;
    biases_bef_L[6*nplans+4] = 0.;
    biases_bef_L[6*nplans+5] = 0.;
    biases_bef_R[6*nplans+3] = 0.;
    biases_bef_R[6*nplans+4] = 0.;
    biases_bef_R[6*nplans+5] = 0.;
        
    //
    // Now the arrays contains the total misalignment for each module
    // We could compute the REAL box offsets, in the canonical approach,
    // and so deduce the individual misalignments we should find with this approach
    //
    
    for (j=0; j<nplans; j++){
      
      // Translations
      
      biases_bef_L[6*nplans]   += biases_bef_L[j];
      biases_bef_L[6*nplans+1] += biases_bef_L[j+nplans];
      biases_bef_L[6*nplans+2] += biases_bef_L[j+2*nplans];
      
      biases_bef_R[6*nplans]   += biases_bef_R[j];
      biases_bef_R[6*nplans+1] += biases_bef_R[j+nplans];
      biases_bef_R[6*nplans+2] += biases_bef_R[j+2*nplans];
      
      // Rotations
      
      biases_bef_L[6*nplans+7] += biases_bef_L[j+3*nplans];
      biases_bef_L[6*nplans+8] += biases_bef_L[j+4*nplans];
      biases_bef_L[6*nplans+5] += biases_bef_L[j+5*nplans];
      
      biases_bef_R[6*nplans+7] += biases_bef_R[j+3*nplans];
      biases_bef_R[6*nplans+8] += biases_bef_R[j+4*nplans];
      biases_bef_R[6*nplans+5] += biases_bef_R[j+5*nplans];
      
      // Shearings & Z-scaling
      
      biases_bef_L[6*nplans+3] += biases_bef_L[j]*(z_l[j+first]-zmoy_L)/s_zmoy_L;
      biases_bef_L[6*nplans+4] += biases_bef_L[j+nplans]*(z_l[j+first]-zmoy_L)/s_zmoy_L;
      biases_bef_L[6*nplans+6] += biases_bef_L[j+2*nplans]*(z_l[j+first]-zmoy_L)/s_zmoy_L;
      
      biases_bef_R[6*nplans+3] += biases_bef_R[j]*(z_r[j+first]-zmoy_R)/s_zmoy_R;
      biases_bef_R[6*nplans+4] += biases_bef_R[j+nplans]*(z_r[j+first]-zmoy_R)/s_zmoy_R;
      biases_bef_R[6*nplans+6] += biases_bef_R[j+2*nplans]*(z_r[j+first]-zmoy_R)/s_zmoy_R;
      
    }      

    //
    // Get the 'canonical' offsets, ie the one we will find with the algorithm STEP 2
    //
    
    for (j=0; j<9; j++){
      biases_bef_L[6*nplans+j] /= nplans;
      biases_bef_R[6*nplans+j] /= nplans;
    }

    // Here are the offset from one box wrt the other (what we look for with overlaps)
    
    double delta_t_X = biases_bef_R[6*nplans+4] + biases_bef_L[6*nplans+4];
    double delta_t_Y = biases_bef_R[6*nplans+3] + biases_bef_L[6*nplans+3];
    double delta_t_Z = biases_bef_R[6*nplans+5] - biases_bef_L[6*nplans+5];
    
    double delta_o_X = -biases_bef_R[6*nplans] - biases_bef_L[6*nplans];
    double delta_o_Y = -biases_bef_R[6*nplans+1] - biases_bef_L[6*nplans+1];
    double delta_o_Z = -biases_bef_R[6*nplans+2] + biases_bef_L[6*nplans+2];
    
    if (print_info)
    {                                                                
      cout << "Compare tilts " << endl;        
      cout << " delta_x  =  " << delta_t_X << " / " << biases_aft_R[6*(nplans+1)+3] << endl;
      cout << " delta_y  =  " << delta_t_Y << " / " << biases_aft_R[6*(nplans+1)+4] << endl;
      cout << " delta_z  =  " << delta_t_Z << " / " << biases_aft_R[6*(nplans+1)+5] << endl;
      
      cout << "After " << endl;        
      cout << " offset_r_x =  " << biases_bef_R[6*nplans] << endl;
      cout << " offset_r_y =  " << biases_bef_R[6*nplans+1] << endl;
      cout << " shear_r_x  =  " << biases_bef_R[6*nplans+4] << endl;
      cout << " shear_r_y  =  " << biases_bef_R[6*nplans+3] << endl;
      cout << " tilt_r_z   =  " << biases_bef_R[6*nplans+5] << endl;
      
      cout << endl;
      cout << " offset_l_x =  " << biases_bef_L[6*nplans] << endl;
      cout << " offset_l_y =  " << biases_bef_L[6*nplans+1] << endl;
      cout << " shear_l_x  =  " << biases_bef_L[6*nplans+4] << endl;
      cout << " shear_l_y  =  " << biases_bef_L[6*nplans+3] << endl;
      cout << " tilt_r_z   =  " << biases_bef_L[6*nplans+5] << endl;
      cout << endl;
      
      cout << "Observed " << endl;        
      cout << " offset_r_x =  " << biases_aft_R[6*nplans] << endl;
      cout << " offset_r_y =  " << biases_aft_R[6*nplans+1] << endl;
      cout << " shear_r_x  =  " << biases_aft_R[6*nplans+4] << endl;
      cout << " shear_r_y  =  " << biases_aft_R[6*nplans+3] << endl;
      
      cout << endl;
      cout << " offset_l_x =  " << biases_aft_L[6*nplans] << endl;
      cout << " offset_l_y =  " << biases_aft_L[6*nplans+1] << endl;
      cout << " shear_l_x  =  " << biases_aft_L[6*nplans+4] << endl;
      cout << " shear_l_y  =  " << biases_aft_L[6*nplans+3] << endl;
      cout << endl;
    }                   
    
    // Correct misalignments from offsets, and get individual misalignments found at STEP 1
    
    for (j=0; j<nplans; j++){

      double z_lev_L = z_l[first+j]-zmoy_L;
      double z_lev_R = z_r[first+j]-zmoy_R;
      
      biases_bef_L[j]          -= biases_bef_L[6*nplans]   + z_lev_L*biases_bef_L[6*nplans+3];
      biases_bef_L[j+nplans]   -= biases_bef_L[6*nplans+1] + z_lev_L*biases_bef_L[6*nplans+4];
      biases_bef_L[j+2*nplans] -= biases_bef_L[6*nplans+2] + z_lev_L*biases_bef_L[6*nplans+6];
      biases_bef_L[j+3*nplans] -= biases_bef_L[6*nplans+7];
      biases_bef_L[j+4*nplans] -= biases_bef_L[6*nplans+8];
      biases_bef_L[j+5*nplans] -= biases_bef_L[6*nplans+5];
      
      biases_bef_R[j]          -= biases_bef_R[6*nplans]   + z_lev_R*biases_bef_R[6*nplans+3];
      biases_bef_R[j+nplans]   -= biases_bef_R[6*nplans+1] + z_lev_R*biases_bef_R[6*nplans+4];
      biases_bef_R[j+2*nplans] -= biases_bef_R[6*nplans+2] + z_lev_R*biases_bef_R[6*nplans+6];
      biases_bef_R[j+3*nplans] -= biases_bef_R[6*nplans+7];
      biases_bef_R[j+4*nplans] -= biases_bef_R[6*nplans+8];
      biases_bef_R[j+5*nplans] -= biases_bef_R[6*nplans+5];
    }  
  }

  ///////////////////////////////////////////////////////////////
  ///////////////////////////////////////////////////////////////
  
  //
  // Now make the plots 
  //
  
double bef_L[6], bef_R[6], aft_L[6], aft_R[6];

for (Int_t j=first_station; j<=(last_station-first); j++) 
{
  double stat = float(j+first);
  
  for (Int_t i=0; i<6; i++) {
    
    bef_L[i]  = biases_bef_L[j+i*nplans];
    bef_R[i]  = biases_bef_R[j+i*nplans];
    
    aft_L[i]  = biases_aft_L[j+i*nplans];
    aft_R[i]  = biases_aft_R[j+i*nplans];
  }
  
  L_tx->Fill(stat,bef_L[0]);
  L_ty->Fill(stat,bef_L[1]);
  L_tz->Fill(stat,bef_L[2]);
  L_rx->Fill(stat,bef_L[3]);
  L_ry->Fill(stat,bef_L[4]);
  L_rz->Fill(stat,bef_L[5]);
  
  compL_tx->Fill(stat,bef_L[0] - aft_L[0]);
  compL_ty->Fill(stat,bef_L[1] - aft_L[1]);
  compL_tz->Fill(stat,bef_L[2] - aft_L[2]);
  compL_rx->Fill(stat,bef_L[3] - aft_L[3]);
  compL_ry->Fill(stat,bef_L[4] - aft_L[4]);
  compL_rz->Fill(stat,bef_L[5] - aft_L[5]);
  
  scatL_tx->Fill(bef_L[0],aft_L[0]);
  scatL_ty->Fill(bef_L[1],aft_L[1]);
  scatL_tz->Fill(bef_L[2],aft_L[2]);
  scatL_rx->Fill(bef_L[3],aft_L[3]);
  scatL_ry->Fill(bef_L[4],aft_L[4]);
  scatL_rz->Fill(bef_L[5],aft_L[5]);
  
  
  R_tx->Fill(stat,bef_R[0]);
  R_ty->Fill(stat,bef_R[1]);
  R_tz->Fill(stat,bef_R[2]);
  R_rx->Fill(stat,bef_R[3]);
  R_ry->Fill(stat,bef_R[4]);
  R_rz->Fill(stat,bef_R[5]);
  
  compR_tx->Fill(stat,bef_R[0] - aft_R[0]);
  compR_ty->Fill(stat,bef_R[1] - aft_R[1]);
  compR_tz->Fill(stat,bef_R[2] - aft_R[2]);
  compR_rx->Fill(stat,bef_R[3] - aft_R[3]);
  compR_ry->Fill(stat,bef_R[4] - aft_R[4]);
  compR_rz->Fill(stat,bef_R[5] - aft_R[5]);
  
  scatR_tx->Fill(bef_R[0],aft_R[0]);
  scatR_ty->Fill(bef_R[1],aft_R[1]);
  scatR_tz->Fill(bef_R[2],aft_R[2]);
  scatR_rx->Fill(bef_R[3],aft_R[3]);
  scatR_ry->Fill(bef_R[4],aft_R[4]);
  scatR_rz->Fill(bef_R[5],aft_R[5]);
  
  for (Int_t i=1; i<2; i++){ 
    
    compt->Fill(bef_R[i]-aft_R[i]);
    compt->Fill(bef_L[i]-aft_L[i]);
  }
  
  for (Int_t i=2; i<3; i++){ 
    
    compr->Fill(bef_R[i+3]-aft_R[i+3]);
    compr->Fill(bef_L[i+3]-aft_L[i+3]);      
  }
}




//
///
//// Then finally make some cosmetics
///
//

/////////////STAT////////   
gStyle -> SetStatW(0.3);
gStyle -> SetStatH(0.2);
gStyle -> SetStatColor(41);   
gStyle -> SetStatX(0.8);
gStyle -> SetStatY(0.8);   
gStyle -> SetStatFont(42);
gStyle -> SetOptStat(0);
gStyle -> SetOptFit(111);
gStyle -> SetPalette(45);
/////////////////////////

ci1 = new TCanvas("ci1","Internal Alignment: Right 1",200,500,700,800);
ci1->SetFillColor(0);
ci1->SetBorderMode(0); 
ci1->Divide(2,3);     

ci1->cd(1);
scatR_tx->SetMarkerStyle(4);
scatR_tx->GetXaxis()->SetTitle("Generated Misalignment (in mm)");
scatR_tx->GetXaxis()->SetTitleSize(0.05);
scatR_tx->GetYaxis()->SetTitle("Reconstructed Misalignment (in mm)");
scatR_tx->GetYaxis()->SetTitleSize(0.05);
scatR_tx->GetYaxis()->SetTitleOffset(1.05);
scatR_tx->Draw();
TPaveText *pt = new TPaveText(-0.08,0.05,-0.04,0.09,"br");
pt->SetTextSize(0.1);
TText *text = pt->AddText("#Delta_{x}");
pt->Draw();

ci1->cd(2);
scatR_rx->SetMarkerStyle(4);
scatL_rx->SetMarkerStyle(4);
scatR_rx->GetXaxis()->SetTitle("Generated Misalignment (in rad)");
scatR_rx->GetXaxis()->SetTitleSize(0.05);
scatR_rx->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
scatR_rx->GetYaxis()->SetTitleSize(0.05);
scatR_rx->GetYaxis()->SetTitleOffset(1.05);
scatR_rx->Draw();
pt = new TPaveText(-0.007,0.0035,-0.0035,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#alpha}");
pt->Draw();

ci1->cd(3);
scatR_ty->SetMarkerStyle(4);
scatL_ty->SetMarkerStyle(4);
scatR_ty->GetXaxis()->SetTitle("Generated Misalignment (in mm)");
scatR_ty->GetXaxis()->SetTitleSize(0.05);
scatR_ty->GetYaxis()->SetTitle("Reconstructed Misalignment (in mm)");
scatR_ty->GetYaxis()->SetTitleSize(0.05);
scatR_ty->GetYaxis()->SetTitleOffset(1.05);
scatR_ty->Draw();
pt = new TPaveText(-0.08,0.05,-0.04,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{y}");
pt->Draw();

ci1->cd(4);
scatR_ry->SetMarkerStyle(4);
scatL_ry->SetMarkerStyle(4);
scatR_ry->GetXaxis()->SetTitle("Generated Misalignment (in rad)");
scatR_ry->GetXaxis()->SetTitleSize(0.05);
scatR_ry->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
scatR_ry->GetYaxis()->SetTitleSize(0.05);
scatR_ry->GetYaxis()->SetTitleOffset(1.05);
scatR_ry->Draw();
pt = new TPaveText(-0.007,0.0035,-0.0035,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#beta}");
pt->Draw();

ci1->cd(5);
scatR_tz->SetMarkerStyle(4);
scatL_tz->SetMarkerStyle(4);
scatR_tz->GetXaxis()->SetTitle("Generated Misalignment (in mm)");
scatR_tz->GetXaxis()->SetTitleSize(0.05);
scatR_tz->GetYaxis()->SetTitle("Reconstructed Misalignment (in mm)");
scatR_tz->GetYaxis()->SetTitleSize(0.05);
scatR_tz->GetYaxis()->SetTitleOffset(1.05);
scatR_tz->Draw();
pt = new TPaveText(-0.08,0.05,-0.04,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{z}");
pt->Draw();

ci1->cd(6);
scatR_rz->SetMarkerStyle(4);
scatL_rz->SetMarkerStyle(4);
scatR_rz->GetXaxis()->SetTitle("Generated Misalignment (in rad)");
scatR_rz->GetXaxis()->SetTitleSize(0.05);
scatR_rz->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
scatR_rz->GetYaxis()->SetTitleSize(0.05);
scatR_rz->GetYaxis()->SetTitleOffset(1.05);
scatR_rz->Draw();
pt = new TPaveText(-0.007,0.0035,-0.0035,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#gamma}");
pt->Draw();

ci1->Update();


ci2 = new TCanvas("ci2","Internal Alignment: Left 1",200,500,700,800);
ci2->SetFillColor(0);
ci2->SetBorderMode(0); 
ci2->Divide(2,3);     

ci2->cd(1);
scatL_tx->SetMarkerStyle(4);
scatL_tx->GetXaxis()->SetTitle("Generated Misalignment (in mm)");
scatL_tx->GetXaxis()->SetTitleSize(0.05);
scatL_tx->GetYaxis()->SetTitle("Reconstructed Misalignment (in mm)");
scatL_tx->GetYaxis()->SetTitleSize(0.05);
scatL_tx->GetYaxis()->SetTitleOffset(1.05);
scatL_tx->Draw();
pt = new TPaveText(-0.08,0.05,-0.04,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{x}");
pt->Draw();
  
ci2->cd(2);
scatL_rx->SetMarkerStyle(4);
scatL_rx->GetXaxis()->SetTitle("Generated Misalignment (in rad)");
scatL_rx->GetXaxis()->SetTitleSize(0.05);
scatL_rx->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
scatL_rx->GetYaxis()->SetTitleSize(0.05);
scatL_rx->GetYaxis()->SetTitleOffset(1.05);
scatL_rx->Draw();
pt = new TPaveText(-0.007,0.0035,-0.0035,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#alpha}");
pt->Draw();

ci2->cd(3);
scatL_ty->SetMarkerStyle(4);
scatL_ty->GetXaxis()->SetTitle("Generated Misalignment (in mm)");
scatL_ty->GetXaxis()->SetTitleSize(0.05);
scatL_ty->GetYaxis()->SetTitle("Reconstructed Misalignment (in mm)");
scatL_ty->GetYaxis()->SetTitleSize(0.05);
scatL_ty->GetYaxis()->SetTitleOffset(1.05);
scatL_ty->Draw();
pt = new TPaveText(-0.08,0.05,-0.04,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{y}");
pt->Draw();  

ci2->cd(4);
scatL_ry->SetMarkerStyle(4);
scatL_ry->GetXaxis()->SetTitle("Generated Misalignment (in rad)");
scatL_ry->GetXaxis()->SetTitleSize(0.05);
scatL_ry->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
scatL_ry->GetYaxis()->SetTitleSize(0.05);
scatL_ry->GetYaxis()->SetTitleOffset(1.05);
scatL_ry->Draw();
pt = new TPaveText(-0.007,0.0035,-0.0035,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#beta}");
pt->Draw();  

ci2->cd(5);
scatL_tz->SetMarkerStyle(4);
scatL_tz->GetXaxis()->SetTitle("Generated Misalignment (in mm)");
scatL_tz->GetXaxis()->SetTitleSize(0.05);
scatL_tz->GetYaxis()->SetTitle("Reconstructed Misalignment (in mm)");
scatL_tz->GetYaxis()->SetTitleSize(0.05);
scatL_tz->GetYaxis()->SetTitleOffset(1.05);
scatL_tz->Draw();
pt = new TPaveText(-0.08,0.05,-0.04,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{z}");
pt->Draw();  

  ci2->cd(6);
scatL_rz->SetMarkerStyle(4);
scatL_rz->GetXaxis()->SetTitle("Generated Misalignment (in rad)");
scatL_rz->GetXaxis()->SetTitleSize(0.05);
scatL_rz->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
scatL_rz->GetYaxis()->SetTitleSize(0.05);
scatL_rz->GetYaxis()->SetTitleOffset(1.05);
scatL_rz->Draw();
pt = new TPaveText(-0.007,0.0035,-0.0035,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#gamma}");
pt->Draw();

ci2->Update();

ci3 = new TCanvas("ci3","Internal Alignment: Right 2",200,500,700,800);
ci3->SetFillColor(0);
ci3->SetBorderMode(0); 
ci3->Divide(2,3);     

ci3->cd(1);
R_tx->SetMarkerStyle(21);
R_tx->SetMarkerStyle(21);
R_tx->GetXaxis()->SetTitle("Velo module number");
R_tx->GetXaxis()->SetTitleSize(0.05);
R_tx->GetYaxis()->SetTitle("Misalignment bef. correction (in mm)");
R_tx->GetYaxis()->SetTitleSize(0.05);
R_tx->GetYaxis()->SetTitleOffset(1.05);
R_tx->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{x}");
pt->Draw();

ci3->cd(2);
compR_tx->SetMarkerStyle(21);
compR_tx->GetXaxis()->SetTitle("Velo module number");
compR_tx->GetXaxis()->SetTitleSize(0.05);
compR_tx->GetYaxis()->SetTitle("Misalignment after correction (in mm)");
compR_tx->GetYaxis()->SetTitleSize(0.05);
compR_tx->GetYaxis()->SetTitleOffset(1.05);
compR_tx->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{x}");
pt->Draw();  

ci3->cd(3);
R_ty->SetMarkerStyle(21);
R_ty->SetMarkerStyle(21);
R_ty->SetMarkerStyle(21);
R_ty->GetXaxis()->SetTitle("Velo module number");
R_ty->GetXaxis()->SetTitleSize(0.05);
R_ty->GetYaxis()->SetTitle("Misalignment bef. correction (in mm)");
R_ty->GetYaxis()->SetTitleSize(0.05);
R_ty->GetYaxis()->SetTitleOffset(1.05);
R_ty->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{y}");
pt->Draw();  

ci3->cd(4);
compR_ty->SetMarkerStyle(21);
compR_ty->GetXaxis()->SetTitle("Velo module number");
compR_ty->GetXaxis()->SetTitleSize(0.05);
compR_ty->GetYaxis()->SetTitle("Misalignment after correction (in mm)");
compR_ty->GetYaxis()->SetTitleSize(0.05);
compR_ty->GetYaxis()->SetTitleOffset(1.05);
compR_ty->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{y}");
pt->Draw();  

ci3->cd(5);
R_rz->SetMarkerStyle(21);
R_rz->SetMarkerStyle(21);
R_rz->SetMarkerStyle(21);
R_rz->GetXaxis()->SetTitle("Velo module number");
R_rz->GetXaxis()->SetTitleSize(0.05);
R_rz->GetYaxis()->SetTitle("Misalignment bef. correction (in rad)");
R_rz->GetYaxis()->SetTitleSize(0.05);
R_rz->GetYaxis()->SetTitleOffset(1.05);
R_rz->Draw();
pt = new TPaveText(1.,0.0035,4.,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#gamma}");
pt->Draw();  

ci3->cd(6);
compR_rz->SetMarkerStyle(21);
compR_rz->GetXaxis()->SetTitle("Velo module number");
compR_rz->GetXaxis()->SetTitleSize(0.05);
compR_rz->GetYaxis()->SetTitle("Reconstructed Misalignment (in rad)");
compR_rz->GetYaxis()->SetTitleSize(0.05);
compR_rz->GetYaxis()->SetTitleOffset(1.05);
compR_rz->Draw();
pt = new TPaveText(1.,0.0035,4.,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#gamma}");
pt->Draw();

ci3->Update();


ci4 = new TCanvas("ci4","Internal Alignment: Left 2",200,500,700,800);
ci4->SetFillColor(0);
ci4->SetBorderMode(0); 
ci4->Divide(2,3);     

ci4->cd(1);
L_tx->SetMarkerStyle(21);
L_tx->SetMarkerStyle(21);
L_tx->SetMarkerStyle(21);
L_tx->GetXaxis()->SetTitle("Velo module number");
L_tx->GetXaxis()->SetTitleSize(0.05);
L_tx->GetYaxis()->SetTitle("Misalignment bef. correction (in mm)");
L_tx->GetYaxis()->SetTitleSize(0.05);
L_tx->GetYaxis()->SetTitleOffset(1.05);
L_tx->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{x}");
pt->Draw();  

ci4->cd(2);
compL_tx->SetMarkerStyle(21);
compL_tx->GetXaxis()->SetTitle("Velo module number");
compL_tx->GetXaxis()->SetTitleSize(0.05);
compL_tx->GetYaxis()->SetTitle("Misalignment after correction (in mm)");
compL_tx->GetYaxis()->SetTitleSize(0.05);
compL_tx->GetYaxis()->SetTitleOffset(1.05);
compL_tx->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{x}");
pt->Draw();  

ci4->cd(3);
L_ty->SetMarkerStyle(21);
L_ty->GetXaxis()->SetTitle("Velo module number");
L_ty->GetXaxis()->SetTitleSize(0.05);
L_ty->GetYaxis()->SetTitle("Misalignment bef. correction (in mm)");
L_ty->GetYaxis()->SetTitleSize(0.05);
L_ty->GetYaxis()->SetTitleOffset(1.05);
L_ty->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{y}");
pt->Draw();

ci4->cd(4);
compL_ty->SetMarkerStyle(21);
compL_ty->GetXaxis()->SetTitle("Velo module number");
compL_ty->GetXaxis()->SetTitleSize(0.05);
compL_ty->GetYaxis()->SetTitle("Misalignment after correction (in mm)");
compL_ty->GetYaxis()->SetTitleSize(0.05);
compL_ty->GetYaxis()->SetTitleOffset(1.05);
compL_ty->Draw();
pt = new TPaveText(1.,0.05,4.,0.09,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{y}");
pt->Draw();  

ci4->cd(5);
L_rz->SetMarkerStyle(21);
L_rz->GetXaxis()->SetTitle("Velo module number");
L_rz->GetXaxis()->SetTitleSize(0.05);
L_rz->GetYaxis()->SetTitle("Misalignment bef. correction (in rad)");
L_rz->GetYaxis()->SetTitleSize(0.05);
L_rz->GetYaxis()->SetTitleOffset(1.05);
L_rz->Draw();
pt = new TPaveText(1.,0.0035,4.,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#gamma}");
pt->Draw(); 
  
ci4->cd(6);
compL_rz->SetMarkerStyle(21);
compL_rz->GetXaxis()->SetTitle("Velo module number");
compL_rz->GetXaxis()->SetTitleSize(0.05);
compL_rz->GetYaxis()->SetTitle("Misalignment after correction (in rad)");
compL_rz->GetYaxis()->SetTitleSize(0.05);
compL_rz->GetYaxis()->SetTitleOffset(1.05);
compL_rz->Draw();
pt = new TPaveText(1.,0.0035,4.,0.007,"br");
pt->SetTextSize(0.1);
text = pt->AddText("#Delta_{#gamma}");
pt->Draw();   

ci4->Update();


ci6 = new TCanvas("ci6","Internal Alignment: resolutions",200,500,700,800);
ci6->SetFillColor(0);
ci6->SetBorderMode(0); 
ci6->Divide(1,2);     

ci6->cd(1);
compt->Draw();
compt->Fit("gaus");
compt->GetXaxis()->SetTitle("Translation after correction (in mm)");
compt->GetXaxis()->SetTitleSize(0.05);

ci6->cd(2);
compr->Draw();
compr->Fit("gaus");
compr->GetXaxis()->SetTitle("Rotation after correction (in rad)");
compr->GetXaxis()->SetTitleSize(0.05);

ci6->Update();
}