// -------------------------------------------------------------------------
// -----		PndSttTrackFinderReal source file	-----
// -----		by Gianluigi Boca		-----
// -------------------------------------------------------------------------
#include "glpk.h"

// Pnd includes
#include "PndSttTrackFinderReal.h"

#include "PndSttHit.h"
#include "PndSttPoint.h"
#include "PndSttHelixHit.h"
#include "PndTrackCand.h"
#include "PndTrack.h"
#include "PndDetectorList.h"
#include "PndSttTube.h"
#include  <cmath>
#include "FairTrackParP.h"
#include "FairMCPoint.h"
#include "FairRootManager.h"
//#include "GFKalman.h"

// ROOT includes
#include "TClonesArray.h"
#include "TDatabasePDG.h"
#include "TRandom.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"

// C++ includes
#include <iostream>
#include <map>

using std::cout;
using std::cin;
using std::endl;
using std::map;


// -----   Default constructor   -------------------------------------------
PndSttTrackFinderReal::PndSttTrackFinderReal()
{ 
	iplotta = false;
	istampa = 0;
	doMcComparison = false;

//  fVerbose      = 1;
                 Fimin=0.;     Fimax=2.*PI;
                 FI0min = 0.; FI0max = 2.*PI;
               stepD=(Dmax-Dmin)/nbinD;
               stepFi=(Fimax-Fimin)/nbinFi;
               stepR=(Rmax-Rmin)/nbinR;
               stepKAPPA=(KAPPAmax-KAPPAmin)/nbinKAPPA;
               stepFI0=(FI0max-FI0min)/nbinFI0;
               stepfineKAPPA=2.*DELTA_KAPPA/nbinKAPPA;
               stepfineFI0=2.*DELTA_FI0/nbinFI0;
	sprintf(fSttBranch,"STTHit");

}
// -------------------------------------------------------------------------




// -----   Standard constructor   ------------------------------------------
PndSttTrackFinderReal::PndSttTrackFinderReal(int verbose) 
{ 
	istampa      = verbose;
	iplotta = false;
	doMcComparison = false;

	MINIMUMOUTERHITSPERTRACK=5;
	Fimin=0.;     Fimax=2.*PI;
	FI0min = 0.; FI0max = 2.*PI;
	stepD=(Dmax-Dmin)/nbinD;
	stepFi=(Fimax-Fimin)/nbinFi;
	stepR=(Rmax-Rmin)/nbinR;
	stepKAPPA=(KAPPAmax-KAPPAmin)/nbinKAPPA;
	stepFI0=(FI0max-FI0min)/nbinFI0;
	stepfineKAPPA=2.*DELTA_KAPPA/nbinKAPPA;
	stepfineFI0=2.*DELTA_FI0/nbinFI0;
	sprintf(fSttBranch,"STTHit");
}
// -------------------------------------------------------------------------


// -----   Second constructor   ------------------------------------------
PndSttTrackFinderReal::PndSttTrackFinderReal(int istamp, bool iplott, bool imc) 
{ 
	istampa= istamp;
	iplotta = iplott;
	doMcComparison = imc;

	MINIMUMOUTERHITSPERTRACK=5;
	Fimin=0.;     Fimax=2.*PI;
	FI0min = 0.; FI0max = 2.*PI;
	stepD=(Dmax-Dmin)/nbinD;
	stepFi=(Fimax-Fimin)/nbinFi;
	stepR=(Rmax-Rmin)/nbinR;
	stepKAPPA=(KAPPAmax-KAPPAmin)/nbinKAPPA;
	stepFI0=(FI0max-FI0min)/nbinFI0;
	stepfineKAPPA=2.*DELTA_KAPPA/nbinKAPPA;
	stepfineFI0=2.*DELTA_FI0/nbinFI0;
	sprintf(fSttBranch,"STTHit");

}
// -------------------------------------------------------------------------



// -----   Destructor   ----------------------------------------------------
PndSttTrackFinderReal::~PndSttTrackFinderReal() 
{ 
}
// -------------------------------------------------------------------------

//----------begin of function PndSttTrackFinderReal::WriteHistograms

void PndSttTrackFinderReal::WriteHistograms(){

//     TFile* file = FairRootManager::Instance()->GetOutFile();
          TFile* file = FairRootManager::Instance()->GetOutFile();
 	  file->cd();
 	  file->mkdir("PndSttTrackFinderReal");
 	  file->cd("PndSttTrackFinderReal");

	hdist->Write();
	hdistgoodlast->Write();
	hdistbadlast->Write();
	delete hdist;
	delete hdistgoodlast;
	delete hdistbadlast;


}

//----------end of function PndSttTrackFinderReal::WriteHistograms


// -----   Public method Init   --------------------------------------------
void PndSttTrackFinderReal::Init() 
{

   UShort_t i, j, k;
   Double_t    r1, r2, A ,
              tempRadiaConf[nRdivConformal];


   MINIMUMHITSPERTRACK=3;

//  --------------------------- opening files for special purposes

N_INTENDED=0;

if(istampa >=1 ){
//---- fetch the n. of tracks MC that were intended to be generated
   HANDLE = fopen("n_intended_tracks.txt","r");
   fscanf(HANDLE,"%d",&N_INTENDED);
   fclose(HANDLE);
//---- apertura file con info su Found tracce su cui si fa Helix fit dopo
   HANDLE2 = fopen("info_da_PndTrackFinderReal.txt","w");

//  ---- open filehandle per statistica sugli hits etc.
   HANDLE = fopen("statistiche.txt","w");
//  ---------------
if(istampa >=3 )   HANDLEXYZ = fopen("infoPndTrackFinderRealXYZ.txt","w");

//  ---------------  open file delle info su deltaX, Y, Z  degli hits in comune tra tracce trovate e MC

   PHANDLEX = fopen("deltaParXmio.txt","w");
   PHANDLEY = fopen("deltaParYmio.txt","w");
   PHANDLEZ = fopen("deltaParZmio.txt","w");
   SHANDLEX = fopen("deltaSkewXmio.txt","w");
   SHANDLEY = fopen("deltaSkewYmio.txt","w");
   SHANDLEZ = fopen("deltaSkewZmio.txt","w");

}  //  end of if(istampa >=1)


// -------------------------



   fHelixHitProduction = true;

   IVOLTE=-1; ntimes = 0;


  // Get and check FairRootManager
  FairRootManager* ioman = FairRootManager::Instance();

//    get   the MCTrack  array

  fMCTrackArray = (TClonesArray*) ioman->GetObject("MCTrack");

//   -------------------------------------------------------------------


  hdist = new TH1F("hdist", "distance (cm)", 20, 0., 10.);
  hdistgoodlast = new TH1F("hDistanceTrulyInnerLast", "distance (cm)", 20, 0., 10.);
  hdistbadlast = new TH1F("hDistanceNonLastInner", "distance (cm)", 20, 0., 10.);

  if (!ioman) 
    {
      cout << "-E- PndSttTrackFinderReal::Init: "
	   << "RootManager not instantised, return!" << endl;
      return;
    }
 
//   calculate the boundaries of the Box in Conformal Space, see Gianluigi logbook on pag. 210-211


    radiaConf[0] = 1./RStrawDetectorMax; 
    r1 = RStrawDetectorMin;
    A = (RStrawDetectorMax - r1)/nRdivConformal;
    if ( nRdivConformal > 1 ) {
      for(i = 1; i< nRdivConformal ; i++){
        r2 = r1 + A;
        tempRadiaConf[nRdivConformal-i] = 1./r2;
        r1=r2;

      }
    }



//  now take into account the zone of the skew straws, which is 'empty' as far as the parallel straws is concerned

      for(i = 1; i< nRdivConformal  ; i++){

        radiaConf[i] = tempRadiaConf[i];
      }
      nRdivConformalEffective = nRdivConformal;

//--------------------  end of method Init   --------------------------------------------



}
// -------------------- starting PndSttTrackFinderReal::GetHitFromCollections

PndSttHit* PndSttTrackFinderReal::GetHitFromCollections(Int_t hitCounter)
{
    PndSttHit
	*retval = NULL;
 
    Int_t
	relativeCounter = hitCounter;

    for (Int_t collectionCounter = 0; collectionCounter < fHitCollectionList.GetEntries(); collectionCounter++)
    {
	Int_t
	    size = ((TClonesArray *)fHitCollectionList.At(collectionCounter))->GetEntriesFast();

	if (relativeCounter < size)
	{
	    retval = (PndSttHit*) ((TClonesArray *)fHitCollectionList.At(collectionCounter))->At(relativeCounter);
	    break;
	}
	else
	{
	    relativeCounter -= size;
	}
    }
    return retval;
}

// -------------------- end of PndSttTrackFinderReal::GetHitFromCollections



// -------------------- starting PndSttTrackFinderReal::GetPointFromCollections

FairMCPoint* PndSttTrackFinderReal::GetPointFromCollections(Int_t hitCounter)
{
    FairMCPoint
	*retval = NULL;
 
    Int_t
	relativeCounter = hitCounter;

    for (Int_t collectionCounter = 0; collectionCounter < fHitCollectionList.GetEntries(); collectionCounter++)
    {
	Int_t
	    size = ((TClonesArray *)fHitCollectionList.At(collectionCounter))->GetEntriesFast();

	if (relativeCounter < size)
	{
	    Int_t
		tmpHit = ((PndSttHit*) ((TClonesArray *)fHitCollectionList.At(collectionCounter))->At(relativeCounter))->GetRefIndex();
	    
	    retval = (FairMCPoint*) ((TClonesArray *)fPointCollectionList.At(collectionCounter))->At(tmpHit);

	    break;
	}
	else
	{
	    relativeCounter -= size;
	}
    }
    return retval;
}


// -------------------- end of PndSttTrackFinderReal::GetPointFromCollections

Int_t PndSttTrackFinderReal::DoFind( TClonesArray* trackCandArray, TClonesArray* helixHitArray) {} // CHECK da cancellare


// -----------------   start of method DoFind
Int_t PndSttTrackFinderReal::DoFind(TClonesArray* trackCandArray, TClonesArray *trackArray, TClonesArray* helixHitArray) 
{

                                                //  list of hit numbers of those falling in this cell
    Short_t Charge[MAXTRACKSPEREVENT],
            Status[MAXTRACKSPEREVENT],
            daTrackFoundaTrackMC[MAXTRACKSPEREVENT],
		enne[MAXTRACKSPEREVENT][nmaxHits];
//            daMCTrackaTrackFound[MAXMCTRACKS];


    UShort_t	emme,
		auxIndex[nmaxHits],
             OLDinfoparal[nmaxHits];
    UShort_t istep,inclination_type, exitstatus;

    Double_t aaa, ddd, delta, deltabis, deltaZ, mindis, distanza, fi_hit,
              ap1, ap2, ap3, carica, cross1, cross2, cross3,
             lowlimit[MAXTRACKSPEREVENT],
             uplimit[MAXTRACKSPEREVENT],
             info[nmaxHits][7],
             WDX, WDY, WDZ,
             auxRvalues[nmaxHits],
             inclination[nmaxinclinationversors][3];

    PndSttHit*  ListPointer_to_Hit[nmaxHits];


    inclination[0][0]=inclination[0][1]=0.,    inclination[0][2]=1.;
    Int_t Nincl = 1, Ninclinate, iHit;
    Int_t Minclinations[nmaxinclinationversors];




//------------------------------------ modifiche Gianluigi, 9-7-08

     IVOLTE++;

     if(istampa>=1) 
         cout<<"\nda PndSttTrackFinderReal : evento (a partire da 0)  n. "<<IVOLTE<<endl;

//------------------------------------ fine modifiche Gianluigi, 9-7-08


  // Check pointers
  if (fHitCollectionList.GetEntries() == 0)
  {
      cout << "-E- PndSttTrackFinderReal::DoFind: "
	   << "No hit arrays present, call AddHitCollection() first (at least once), return! " << endl;
      return -1;
  }

  if (fPointCollectionList.GetEntries() == 0)
  {
      cout << "-E- PndSttTrackFinderReal::DoFind: "
	   << "No point arrays present, call AddHitCollection() first (at least once), return! " << endl;
      return -1;
  }

  if ( !trackCandArray ) 
    {
      cout << "-E- PndSttTrackFinderReal::DoFind: "
	   << "Track array missing! " << endl;
      return -1;
    }

//       PndMCTrack*      pMCtr = NULL;     //  questo e' gia' definito in PndSttTrackFinderReal.h
   nMCTracks = fMCTrackArray->GetEntriesFast(); // num. tracce/evento
   if(istampa>=1)  cout<<"Gianluigi, evento n. "<<IVOLTE<<", n. tracce MC = "<<nMCTracks<<endl;

  // Number of STT hits
  Int_t Nhits = 0;
  
  for (Int_t hitListCounter = 0; hitListCounter < fHitCollectionList.GetEntries(); hitListCounter++)
  {
      Nhits += ((TClonesArray *)fHitCollectionList.At(hitListCounter))->GetEntriesFast();
  }

  if(Nhits <   MINIMUMHITSPERTRACK) {
    cout<<"from PndSttTrackFinderReal :  # Stt hits (|| + //) = "<<Nhits
    <<" and it is < MINIMUMHITSPERTRACK = "
    <<MINIMUMHITSPERTRACK<<", return !"<<endl;
    return  -10;
  }

  if(Nhits >= nmaxHits ) {
    cout<<"from PndSttTrackFinderReal :  # Stt hits (|| + //)  = "<<Nhits<<" and it is >= nmaxHits = "
    <<nmaxHits<<", return !"<<endl;
    return  -10;
  }


/*
   if(istampa>=1 && (nMCTracks  != N_INTENDED)  ){
    cout<<"Evento n. "<<IVOLTE<<" : n. MC tracks = "<<nMCTracks
    <<" and it is different from n. intended tracks (= "<<
        N_INTENDED<<"), returning!\n";
    return  -20;
  }
*/

    
  // Initialise control counters
  Int_t nNoTrack     = 0;
  Int_t nNoSttPoint  = 0;
  Int_t nNoSttHit    = 0;

  // Create pointers to hit and SttPoint
  PndSttHit*       pMhit = NULL;
  FairMCPoint*      pMCpt = NULL;
//   PndSttTrack*     pTrck[MAXTRACKSPEREVENT] ; // this is for the hits found by pattern recognition


  // Declare some variables outside the loops
  Int_t trackIndex   = 0;     // STTTrack index

  // Create STL map from MCtrack index to number of valid SttHits
  map<Int_t, map<Double_t, Int_t> >
    hitMap;



    for(Int_t j=0; j<nmaxinclinationversors;j++){
     Minclinations[j]=0;
    }

    NSkewhits=Ninclinate=0;


  if (istampa >= 1 ) cout<<"Gianluigi : da PndSttTrackFinderReal::DoFind : Nhits="<<Nhits<<endl;

  //   generated momenta and starting position of each track




  // Loop over hits
  for (iHit = 0; iHit < Nhits; iHit++) 
    {
      // hit point
      pMhit = GetHitFromCollections(iHit);   // <== PndSttHit
      ListPointer_to_Hit[iHit]=pMhit;
      if (!pMhit){
       cout<<"from PndSttTrackFinderReal :  # Stt hits pointer missing, return!\n";
       continue;
      }
      
      // MC point
      Int_t ptIndex = pMhit->GetRefIndex();
	if (ptIndex >= 0) {
		pMCpt = GetPointFromCollections(iHit); // <== FairMCPoint

	}




//      if (ptIndex < 0) continue;           // fake or background hit
//      if (!pMCpt){
//       cout<<"from PndSttTrackFinderReal :  # MC points pointer missing, return!\n";
//       continue;
//      }
      
      // tubeID  CHECK added
      Int_t tubeID = pMhit->GetTubeID();
      PndSttTube *tube = (PndSttTube*) fTubeArray->At(tubeID);
      // real hit center of tube coordinates
      TVector3 center = tube->GetPosition();

      // drift radius
      Double_t dradius = pMhit->GetIsochrone();

      // wire direction
      TVector3 wiredirection = tube->GetWireDirection();

      // "real" MC coordinates (in + out)/2.
//      TVector3 mcpoint;
//      pMCpt->Position(mcpoint);

      if(wiredirection.Z() >=0.) {
       WDX = wiredirection.X();     WDY = wiredirection.Y(); WDZ = wiredirection.Z();
      } else {
       WDX = -wiredirection.X();     WDY = -wiredirection.Y(); WDZ = -wiredirection.Z();
      }


      // stampe di controllo


      info[iHit][0]= tube->GetPosition().X();
      info[iHit][1]= tube->GetPosition().Y();
      info[iHit][2]= tube->GetPosition().Z();
      info[iHit][3]= dradius;
      info[iHit][4]= tube->GetHalfLength();
	if (ptIndex >= 0) {
		info[iHit][6]= pMCpt->GetTrackID();
	}else{
		info[iHit][6]= -20.;
	}

      if( fabs( WDX )< 0.00001 && fabs( WDY )< 0.00001 ){
          info[iHit][5]= 1.;
          infoparal[Minclinations[0]]= iHit ;
          Minclinations[0]++;
          ZCENTER_STRAIGHT = info[iHit][2];      //    this works because just few lines below there is the
          SEMILENGTH_STRAIGHT = info[iHit][4];   //    requirement that Minclinations[0] > 2 (= at least 3 parallel straws)
      } else {
       for (Int_t i=2; i<=Nincl;i++) {
        if (fabs( WDX-inclination[i-1][0] )< 0.00001
                                &&
            fabs( WDY -inclination[i-1][1])< 0.00001
                                &&
            fabs( WDZ -inclination[i-1][2])< 0.00001
                                           ){
          info[iHit][5]= i;
          infoskew[Ninclinate]= iHit;
          Ninclinate++;
          Minclinations[i-1]++;
          goto jumpout;
        }
       }
       Nincl++;
       inclination[Nincl-1][0]=(Double_t) WDX;
       inclination[Nincl-1][1]=(Double_t) WDY;
       inclination[Nincl-1][2]=(Double_t) WDZ;
       info[iHit][5]= Nincl;
          infoskew[Ninclinate]= iHit;
          Ninclinate++;
       Minclinations[Nincl-1]++;
jumpout: ;
      }

      NSkewhits = Ninclinate;


//   calcoli validi solo per il MC   -----------------------------

	if (ptIndex >= 0) {
		veritaMC[iHit][0]= pMCpt->GetX();
		veritaMC[iHit][1]= pMCpt->GetY();
		veritaMC[iHit][2]= pMCpt->GetZ();
	}

//	FromHitToMCTrack[iHit] = (Short_t) ( info[iHit][6] + 0.001 );



//--------------- inizio stampaggi,  stampe di controllo
  if (istampa >= 2  && IVOLTE<= nmassimo) {
     cout <<"iHit "<< iHit << endl;
      	if (ptIndex < 0) {
cout<<"from PndSttTrackFinderReal...this hit must be noise (RefIndex = "<<ptIndex
	<<" )\n\t\t\tnot associate to any MC Track\n";
//         cout<<"             this hit belongs to MC track n. "<<pMCpt->GetTrackID()<<endl;
	}else{
      cout <<"             MC point X, Y, Z space position "   << veritaMC[iHit][0] << " " <<
                       veritaMC[iHit][1] << " " << veritaMC[iHit][2]<<endl; 
	}
      cout <<"             hit wire pos. in middle "   << tube->GetPosition().X() << " " << tube->GetPosition().Y() << " " << tube->GetPosition().Z() 
           << "; R = "<<sqrt(tube->GetPosition().X()*tube->GetPosition().X()+tube->GetPosition().Y()*tube->GetPosition().Y())<< endl;
      cout <<"             wire direction, X, Y, Z (Z direction set always positive)"
      	<< WDX<<"  "<<WDY<<"  "<<WDZ <<endl;
  }  //  end of   if(istampa >= 

//--------  fine stampaggi





    }   //   end  of  for (Int_t iHit = 0;




//--------------- inizio stampaggi
//  if (istampa >= 2  && IVOLTE<= nmassimo) {
  if (istampa >= 2  ) {
      cout<<"Gianluigi : da PndSttTrackFinderReal::DoFind : Nhits totali ="<<Nhits<<",  n Hits ||  = "<<Minclinations[0]<<
          ",  n Hits  skew = "<<NSkewhits<<endl;
  }  //  end of   if(istampa >=
//--------  fine stampaggi








//   ordering the hits by INCREASING CONFORMAL RADIUS or equivalently, decreasing spatial radius.

    for (int j = 0; j< Minclinations[0]; j++){
      auxIndex[j]=j;
      auxRvalues[j]=
                    info[ infoparal[ j ]  ][0]*
                    info[ infoparal[ j ]  ][0]+
                    info[ infoparal[ j ]  ][1]*
                    info[ infoparal[ j ]  ][1];
      OLDinfoparal[j]=infoparal[j];
    }


    Merge_Sort( Minclinations[0], auxRvalues, auxIndex);
    for (int j = 0; j< Minclinations[0]; j++){
      infoparal[ Minclinations[0]-1-j]  =  OLDinfoparal[ auxIndex[ j ]   ];
    }

//----------------------------







//   if( !( Nhits >0 &&  Minclinations[0] > 2 ) ) return 0;
   if( Minclinations[0] <MINIMUMHITSPERTRACK   ) {
     cout<< "from PndSttTrackFinderReal :  # Stt || hits = "<< Minclinations[0]
         <<" and it is < MINIMUMHITSPERTRACK = "<<MINIMUMHITSPERTRACK<<", return!"<<endl;
	  return 0;
   }





  bool	Consider,
	ExclusionList[nmaxHits],      //  list of || hits  already assigned to a found track or with multiple hits
	ExclusionListSkew[nmaxHits],      //  list of skew hits with multiple hits
	ExclusionListbis[nmaxHits],      //  list of || hits ONLY with multiple hits
	ExclusionListSkewbis[nmaxHits],      //  list of skew hits ONLY with multiple hits (duplicate of
						//		ExclusionListSkew)
	TypeConf[MAXTRACKSPEREVENT],   //  if TypeConf[]=false --> the track is a line in the Conformal space,
					//   if TypeConf[]=true it is a crf;
	TypeConfSkew[MAXTRACKSPEREVENT],
	GoodTrack[MAXTRACKSPEREVENT];    //  yes = track found passes minimal requirements



  UShort_t iExclude,
           imc,jexp,mchit,exphit,
           nTracksFoundSoFar,
           NN,
           NNN,
           Nouter,
           Naux,
           Nbaux,
           nTotalHits[MAXTRACKSPEREVENT],
           iParHit,
           SeedParallelNumber,
           OLDnHitsinTrack,
           TemporarynSkewHitsinTrack,
           BigList[MAXTRACKSPEREVENT][nmaxHits],
           TemporarySkewList[nmaxHits][2],
           nHitsinTrack[MAXTRACKSPEREVENT],
           nSkewHitsinTrack[MAXTRACKSPEREVENT],
           tempore[nmaxHits],
           auxListHitsinTrack[nmaxHits],
           ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
           ListHitsinTrackinWhichToSearch[nmaxHits],
           OLDListHitsinTrack[nmaxHits],
           OutputListHitsinTrack[nmaxHits],
           OutputList2HitsinTrack[nmaxHits],
           ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
           nMCParalAlone[MAXTRACKSPEREVENT],
           nMCSkewAlone[MAXTRACKSPEREVENT],
           MCParalAloneList[MAXTRACKSPEREVENT][nmaxHits],
           MCSkewAloneList[MAXTRACKSPEREVENT][nmaxHits],
           nParalCommon[MAXTRACKSPEREVENT],
           ParalCommonList[MAXTRACKSPEREVENT][nmaxHits],
           nSpuriParinTrack[MAXTRACKSPEREVENT],
           ParSpuriList[MAXTRACKSPEREVENT][nmaxHits],
           nSkewCommon[MAXTRACKSPEREVENT],
           SkewCommonList[MAXTRACKSPEREVENT][nmaxHits],
           nSpuriSkewinTrack[MAXTRACKSPEREVENT],
           SkewSpuriList[MAXTRACKSPEREVENT][nmaxHits],
           RConformalIndex[nmaxHits],  //  given a Hit number it gives its radial box number
           FiConformalIndex[nmaxHits],  //  given a Hit number it gives its azimuthal box number
           nBoxConformal[nRdivConformal][nFidivConformal];  //  first index -> radial divisions, 2nd index -> azimuthal divisions; n. of
                                                            //  hits falling in this cell

//	UShort_t HitsinBoxConformal[Nhits][nRdivConformal][nFidivConformal];
	UShort_t HitsinBoxConformal[MAXHITSINCELL][nRdivConformal][nFidivConformal];
		//  first index -> radial divisions, 2nd index -> azimuthal divisions;

	Short_t flagStt;

   Int_t status;


   Int_t  i, j,ii,jj,k,kk,n1,n2,n3,
          i1,j1,k1,imaxima, jmaxima,
          iofmax, jofmax, kofmax,
          index[nmaxHits], integer,
          Ncirc, nSkew1, nSkew2,
          n_K, n_FI0, n_R, n_D, n_Fi,STATUS,
          Nremaining, Nremaining2,
          NumberofMaximaDFiR,
          NumberofMaximaKFI0,
          nAssociatedParallelHits ;

   int   iimax,jjmax,  ncount;


   Double_t angle, Distance, max1, HoughR, HoughD, HoughFi, HoughKAPPA, HoughFI0,
	      Px, Py,
              tempR, tempD,tempFi,tempKAPPA,tempFI0,
              Rlow, Rup, Dlow, Dup,Filow,Fiup, KAPPAlow, KAPPAup, FI0low, FI0up,
              gamma;

   Double_t    D,Fi, rotationangle, rotationsin, rotationcos,ptotal,
               Fi_low_limit[MAXTRACKSPEREVENT],
               Fi_up_limit[MAXTRACKSPEREVENT],
               Fi_initial_helix_referenceframe[MAXTRACKSPEREVENT],
               Fi_final_helix_referenceframe[MAXTRACKSPEREVENT],
               m[MAXTRACKSPEREVENT],
               q[MAXTRACKSPEREVENT],
               ALFA[MAXTRACKSPEREVENT],
               BETA[MAXTRACKSPEREVENT],
               GAMMA[MAXTRACKSPEREVENT],
               R[MAXTRACKSPEREVENT],
               Ox[MAXTRACKSPEREVENT],
               Oy[MAXTRACKSPEREVENT],
               KAPPA[MAXTRACKSPEREVENT],
               FI0[MAXTRACKSPEREVENT],
               trajectory_vertex[3],
               infoparalConformal[nmaxHits][5],
               auxinfoparalConformal[nmaxHits][5],
               S[2*nmaxHits],
               Z[2*nmaxHits],
               temporeS[nmaxHits],
               temporeZ[nmaxHits],
               ZDrift[2*nmaxHits],
               ZErrorafterTilt[2*nmaxHits],
               temporeZDrift[nmaxHits],
               temporeZErrorafterTilt[nmaxHits],
               Posiz[3],
               Posiz1[3],
               Posiz2[3],
	       versor[3],
	       U[MAXTRACKSPEREVENT][nmaxHits],
	       V[MAXTRACKSPEREVENT][nmaxHits],
               Xpos_for_LHeTrack[nmaxHits],
               Ypos_for_LHeTrack[nmaxHits],
               Zpos_for_LHeTrack[nmaxHits],
               Sfinal[MAXTRACKSPEREVENT][nmaxHits],
               Zfinal[MAXTRACKSPEREVENT][nmaxHits],
               ZDriftfinal[MAXTRACKSPEREVENT][nmaxHits],
               ZErrorafterTiltfinal[MAXTRACKSPEREVENT][nmaxHits];



    Float_t RemainingR[nmaxHits],
            RemainingFi[nmaxHits],
            RemainingD[nmaxHits],
            RemainingCX[nmaxHits],
            RemainingCY[nmaxHits],
            RemainingKAPPA[nmaxHits],
            RemainingFI0[nmaxHits];
    bool    GoodSkewFit[nmaxHits];


    bool            temporflag[8],
            IFLAG;


   CalculatedCircles Result;
   CalculatedHelix   HelixResult;
//   AssociatedHitsToHelix ResultAssociatedHits ;

   char nomef[100], nome[30],titolo[100];






       for(i=0; i< Minclinations[0]; i++){
         ExclusionList[   infoparal[i]   ]= true ;
         ExclusionListbis[   infoparal[i]   ]= true ;
      }
      for(i=0; i< NSkewhits; i++){
         ExclusionListSkew[   infoskew[i]   ]= true ;
         ExclusionListSkewbis[   infoskew[i]   ]= true ;
      }





//-----------------------------------   exclusion of straws with multiple hits

      //   first the parallel straws
      for(i=0; i< Nhits-1; i++){
	if( info[i][5]==1.){
		if( ExclusionList[ i ] ){
			for(j=i+1; j< Nhits; j++){
				if(ExclusionList[ j ] && info[j][5]==1. &&
					fabs(info[i][0] - info[j][0])<1.e-20 &&
					fabs(info[i][1] - info[j][1])<1.e-20  )
				{
					ExclusionList[j]= false ;
					ExclusionListbis[j]= false ;
				}
			} //  end of  for(j=i+1; j< Nhits;; j++)
		}  //   end of if( ExclusionList[ i ] )
	} else {	//  continuation of  if( info[i][5]==1.)

		if( ExclusionListSkew[ i ] ){
			for(j=i+1; j< Nhits; j++){
				if(ExclusionListSkew[ j ] && info[j][5] != 1. &&
					fabs(info[i][0] - info[j][0])<1.e-20 &&
					fabs(info[i][1] - info[j][1])<1.e-20  )
				{
					ExclusionListSkew[j]= false ;
					ExclusionListSkewbis[j]= false ;
				}
			} //  end of  for(j=i+1; j< Nhits;; j++)
		}  //   end of if( ExclusionList[ i ] )


	}	//	//  end of  if( info[i][5]==1.)

      }   //   end of for(i=0; i< Nhits-1; i++)





//-----------------------------------  end of exclusion of straws with multiple hits





      trajectory_vertex[0]=trajectory_vertex[1]=trajectory_vertex[2]=0.;

      PndSttFromXYtoConformal(trajectory_vertex,info, Minclinations[0],infoparalConformal, &status);



      PndSttBoxConformalFilling(
				ExclusionList,
				infoparalConformal,
				Minclinations[0],
				nBoxConformal,
				HitsinBoxConformal,
				RConformalIndex,
				FiConformalIndex);



//     start the track finding procedure


//----- loop over the parallel hits

  nTracksFoundSoFar=0;    // # tracks found

//   begins the first iteration with more severe cuts on the # hits in track candidate

  for(iParHit=0; iParHit<Minclinations[0] + 1 -  MINIMUMHITSPERTRACK ; iParHit++) {
      if( nTracksFoundSoFar > MAXTRACKSPEREVENT) continue;
      if( ! ExclusionList[    infoparal[iParHit]  ] )  continue;
      nHitsinTrack[nTracksFoundSoFar] = PndSttFindTrackPatterninBoxConformal(
                           1,   //  distance in R cells allowed
                           2,   //  distance in Fi cells allowed
                           Minclinations[0],
                           iParHit,
                           info,
                           ExclusionList,
                           RConformalIndex,
                           FiConformalIndex,
                           nBoxConformal,
                           HitsinBoxConformal,
                           &ListHitsinTrack[nTracksFoundSoFar][0]
                                                    );


 if(istampa>=3){
        cout<<" \tSttTrackFinderReal : track found n. "<<nTracksFoundSoFar <<
	" and nHitsinTrack = "<<nHitsinTrack[nTracksFoundSoFar]<<
  " and if it is < the MINIMUMHIITSPERTRACK ("<< MINIMUMHITSPERTRACK<<
  ") this candidate track is skipped\n";
  cout<<"\tList of || stt hits in this candidate (earlier stage) :\n";
  for(int iq=0;iq<nHitsinTrack[nTracksFoundSoFar];iq++){
  	cout<<"\tStt || hit n. (original notation) : "<<
	infoparal[ ListHitsinTrack[nTracksFoundSoFar][iq] ]<<endl; 
  }
 }

      if( nHitsinTrack[nTracksFoundSoFar] < MINIMUMHITSPERTRACK ||
	 nHitsinTrack[nTracksFoundSoFar]>nmaxHitsInTrack) {
        continue;
      }



//-----------------------

//   find among the ListHitsinTrack  if there are at least a minimum # of hits belonging to the outer part
//   of the STT  system

      for(j=0, Nouter =0; j<nHitsinTrack[nTracksFoundSoFar]; j++){
         if(info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][0]* info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][0]+
            info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][1]* info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][1]
            < ApotemaMaxSkewStraw*ApotemaMaxSkewStraw  )   break;
         Nouter++;
      }


     if( Nouter >= MINIMUMOUTERHITSPERTRACK) {

      for(i=0; i< Nouter;i++){
          ListHitsinTrackinWhichToSearch[i]=ListHitsinTrack[nTracksFoundSoFar][i];
      }





      for(i=0; i< Nouter;i++){
        SeedParallelNumber = ListHitsinTrackinWhichToSearch[i];
        Naux =  PndSttFindTrackPatterninBoxConformalSpecial(
                           3,    // NRCELLDISTANCE
                           1,    // NFiCELLDISTANCE
                           Minclinations[0],
                           Nouter,
                           SeedParallelNumber,
                           ListHitsinTrackinWhichToSearch,
                           info,
                           ExclusionList,
                           RConformalIndex,
                           FiConformalIndex,
                           nBoxConformal,
                           HitsinBoxConformal,
                           OutputListHitsinTrack);

// cout<<" Naux = "<<Naux<<", MINIMUMOUTERHITSPERTRACK = "<<MINIMUMOUTERHITSPERTRACK
//	<<", Nouter = " <<Nouter<<endl;

      if( Naux >= MINIMUMOUTERHITSPERTRACK && Naux > 0.7 * Nouter )  break;

      if( Naux >= MINIMUMOUTERHITSPERTRACK) {
//   further collection of hits in the inner region but this time strictly connected to the outer ones

//  first the list of non outer hits
         for(j=Nouter;j<nHitsinTrack[nTracksFoundSoFar]; j++){
            ListHitsinTrackinWhichToSearch[j-Nouter] = ListHitsinTrack[nTracksFoundSoFar][j];
         }



         Nbaux =  PndSttFindTrackStrictCollection(
                           1,    // NFiCELLDISTANCE
                           SeedParallelNumber,   //  seed hit
                           nHitsinTrack[nTracksFoundSoFar]-Nouter,
                           ListHitsinTrackinWhichToSearch,
                           ExclusionList,
                           FiConformalIndex,
                           OutputList2HitsinTrack
                                                );
//   add the new hits found to the list
         nHitsinTrack[nTracksFoundSoFar]=Naux+Nbaux;
         for(j=0;j<Naux;j++){
            ListHitsinTrack[nTracksFoundSoFar][j] = OutputListHitsinTrack[j];
         }
         for(j=0;j<Nbaux;j++){
            ListHitsinTrack[nTracksFoundSoFar][Naux+j] = OutputList2HitsinTrack[j];
         }
         break;
      }  // end of  if( Naux >= MINIMUMOUTERHITSPERTRACK)

      }   // end of for(i=0; i< Nouter;i++)
     }    // end of if( Nouter >= MINIMUMOUTERHITSPERTRACK)


      if( nHitsinTrack[nTracksFoundSoFar] < MINIMUMHITSPERTRACK ||
	 nHitsinTrack[nTracksFoundSoFar]>nmaxHitsInTrack) {
        continue;
      }

//---------------------------

//  finding the rotation angle for best utilization of the MILP procedure

      for(j=0, rotationcos=0., rotationsin=0.; j<nHitsinTrack[nTracksFoundSoFar]; j++){
         rotationcos += cos( (0.5+ FiConformalIndex[ infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ] ])
                                      *2.*PI/nFidivConformal) ;
         rotationsin += sin( (0.5+ FiConformalIndex[ infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ] ])
                                      *2.*PI/nFidivConformal) ;
      }
      rotationcos /=nHitsinTrack[nTracksFoundSoFar];
      rotationsin /=nHitsinTrack[nTracksFoundSoFar];
      rotationangle = atan2(rotationsin, rotationcos);



//  fitting with superfast MILP code

//  first redefine the center of the conformal plane; it will be centered in the center of the  hit in the
//  hit list with the LEAST drift radius; this hit has to be excluded from the fitting


      trajectory_vertex[0]=  0.;
      trajectory_vertex[1]=  0.;



  for(j=0; j<nHitsinTrack[nTracksFoundSoFar]; j++){
    for(i=0; i<5;i++){
      auxinfoparalConformal[j][i] = infoparalConformal[ ListHitsinTrack[nTracksFoundSoFar][j]  ][i];
    }
  }



      INTERO=1;

      Status[nTracksFoundSoFar] = PndSttFitHelixCylinder( 
                nHitsinTrack[nTracksFoundSoFar],
                auxinfoparalConformal,
                nTracksFoundSoFar,
                rotationangle,
                trajectory_vertex,
                NHITSINFIT,
                &m[nTracksFoundSoFar],
                &q[nTracksFoundSoFar],
                ALFA,
                BETA,
                GAMMA,
                TypeConf
                      );

      if(Status[nTracksFoundSoFar] < 0  ) continue;


//  this trasformation is valid even if the equation is a straight line from the fit

      Ox[nTracksFoundSoFar]= -0.5*ALFA[nTracksFoundSoFar];
      Oy[nTracksFoundSoFar]= -0.5*BETA[nTracksFoundSoFar];
      R[nTracksFoundSoFar]= Ox[nTracksFoundSoFar]*Ox[nTracksFoundSoFar]+Oy[nTracksFoundSoFar]*Oy[nTracksFoundSoFar]-
                            GAMMA[nTracksFoundSoFar];
 if(istampa>=2){
        cout<<" \tSttTrackFinderReal : track n. "<<nTracksFoundSoFar<<
	" and nHitsinTrack = "<<nHitsinTrack[nTracksFoundSoFar]<<endl;
  cout<<"\tList of || stt hits in this candidate (intermediate stage) :\n";
  for(int iq=0;iq<nHitsinTrack[nTracksFoundSoFar];iq++){
  	cout<<"\tStt || hit n. (original notation) : "<<
	infoparal[ ListHitsinTrack[nTracksFoundSoFar][iq] ]<<endl; 
  }
  cout<<"\tOx = "<<Ox[nTracksFoundSoFar]<<",  Oy = "<<Oy[nTracksFoundSoFar]<<
  ",  R*R = "<<R[nTracksFoundSoFar]<<", and Status = "<<Status[nTracksFoundSoFar]<<endl;
 }

	// some obvious preliminary cuts
	if( R[nTracksFoundSoFar] < 0. )   continue;
	R[nTracksFoundSoFar]= sqrt( R[nTracksFoundSoFar] );
	aaa = sqrt(Ox[nTracksFoundSoFar]*Ox[nTracksFoundSoFar]+
		Oy[nTracksFoundSoFar]*Oy[nTracksFoundSoFar]);
	// the following is because the circumference is supposed to come from (0,0);
	//   here the factor 0.9 is used in order to be conservative.
	if(aaa< 0.9*RadiusMinStrawDetector/2.) continue;
	//   here the factor 0.9 is used in order to be conservative.
	if ( R[nTracksFoundSoFar] + aaa < RadiusMinStrawDetector *0.9 ) continue;

//---------------------------




//---------------------  better association of the hits in the track candidate

  ITRACCIA = nTracksFoundSoFar;



// treat differently the case in which the track has radius < RStrawDetectorMax/2
// and the other case.

  if( R[nTracksFoundSoFar] < RStrawDetectorMax/2){
	PndSttFindingParallelTrackAngularRange(
		Ox[nTracksFoundSoFar],
		Oy[nTracksFoundSoFar],
		R[nTracksFoundSoFar],
		1,  /// this is supposed to be the charge, irrelevant here if it is +1 or -1.
		&Fi_low_limit[nTracksFoundSoFar],
		&Fi_up_limit[nTracksFoundSoFar],
		&flagStt,
		RStrawDetectorMin,
		RStrawDetectorMax
		);

	NN =  PndSttTrkAssociatedParallelHitsToHelix5(
		ExclusionList,
                   Minclinations[0],
                   Ox[nTracksFoundSoFar],
                   Oy[nTracksFoundSoFar],
                   R[nTracksFoundSoFar],
                   info,
		Fi_low_limit[nTracksFoundSoFar],
		Fi_up_limit[nTracksFoundSoFar],
                   auxListHitsinTrack              //  this is the output
                                                     );


  }  else {

	NN =  PndSttTrkAssociatedParallelHitsToHelixQuater(
		   ExclusionList,
                   m[nTracksFoundSoFar],
                   q[nTracksFoundSoFar],
                   Status[nTracksFoundSoFar],
                   nHitsinTrack[nTracksFoundSoFar],
                   &ListHitsinTrack[nTracksFoundSoFar][0],
                   Minclinations[0],
                   Ox[nTracksFoundSoFar],
                   Oy[nTracksFoundSoFar],
                   R[nTracksFoundSoFar],
                   info,
                   infoparalConformal,
                   RConformalIndex,
                   FiConformalIndex,
                   nBoxConformal,
                   HitsinBoxConformal,
                   auxListHitsinTrack              //  this is the output
                                                     );
  } // end of  if( R[nTracksFoundSoFar] < RStrawDetectorMax/2)




	if( NN < MINIMUMHITSPERTRACK || NN>nmaxHitsInTrack)continue;

   nHitsinTrack[nTracksFoundSoFar]=NN;
   for(i=0; i<nHitsinTrack[nTracksFoundSoFar];i++){
     ListHitsinTrack[nTracksFoundSoFar][i]=auxListHitsinTrack[i];
   }

//----------------------------- Finding the CHarge
	// The charge is calculated first by dividing the hits in two categories by using the Perpendicular
	// to the tangent to the trajectory in (0,0). Then simply the majority of the hits decides the
	// sign of the  charge. See Gianluigi's Logbook page 290.


	FindCharge(
		Ox[nTracksFoundSoFar],
		Oy[nTracksFoundSoFar],
		info,
		nHitsinTrack[nTracksFoundSoFar],
		&ListHitsinTrack[nTracksFoundSoFar][0],
		infoparal,
		&Charge[nTracksFoundSoFar]
		);
//----------------------------- Ordering.
	// The ordering reflects the angle Fi in the Helix reference frame because
	// the hits are ordered by going around the trajectory cclockwise for
	// positive tracks or counterclockwise for negative particles; in other words
	//  it is not used simply the distance of the hit from (0,0) as ordering parameter
	//  but the track length of the circle.
	// this method finds also Fi_initial_helix_referenceframe and Fi_final_helix_referenceframe.
	// The former is simply the fi angle of the point (0,0) with respect to the center
	// of this Helix. Important : this angle has to be > 0 always and it is between 0. and
	// 2 PI here (later,  FixDiscontinuitiesFiangleinSZplane may change it adding +2PI or
	// -2PI if necessary).
	// Fi_final_helix_referenceframe is made such that  it is < Fi_initial_helix_referenceframe
	// when the track is  positive, and it is > Fi_initial_helix_referenceframe for negative
	// tracks.

       PndSttOrderingParallel(
                             Ox[nTracksFoundSoFar],
                             Oy[nTracksFoundSoFar],
                             info,
                             nHitsinTrack[nTracksFoundSoFar],
                             &ListHitsinTrack[nTracksFoundSoFar][0],
                             infoparal,
                             Charge[nTracksFoundSoFar],
                             &Fi_initial_helix_referenceframe[nTracksFoundSoFar],//output
                             &Fi_final_helix_referenceframe[nTracksFoundSoFar],// output
		&U[nTracksFoundSoFar][0],
		&V[nTracksFoundSoFar][0]
                       );


//    end of ordering the parallel  hits; determining the charge of this track

//   finding the FI angular range (in the laboratory frame) spanned by this parallel track

       PndSttFindingParallelTrackAngularRange(
                             Ox[nTracksFoundSoFar],
                             Oy[nTracksFoundSoFar],
                             R[nTracksFoundSoFar],
                             Charge[nTracksFoundSoFar],
                             &Fi_low_limit[nTracksFoundSoFar],
                             &Fi_up_limit[nTracksFoundSoFar],
		&flagStt,
		RStrawDetectorMin,
		RStrawDetectorMax
                                             );


//---------stampaggi.
 if(istampa>=2){
        cout<<" \tSttTrackFinderReal : track n. "<<nTracksFoundSoFar<<
	" and nHitsinTrack = "<<nHitsinTrack[nTracksFoundSoFar]<<endl;
  cout<<"\tList of || stt hits in this candidate (final stage and after Ordering) :\n";
  for(int iq=0;iq<nHitsinTrack[nTracksFoundSoFar];iq++){
  	cout<<"\tStt || hit n. (original notation) : "<<
	infoparal[ ListHitsinTrack[nTracksFoundSoFar][iq] ]<<endl; 
  }
  cout<<"\tOx = "<<Ox[nTracksFoundSoFar]<<",  Oy = "<<Oy[nTracksFoundSoFar]<<
  ",  R = "<<R[nTracksFoundSoFar]<<", and Status = "<<Status[nTracksFoundSoFar]<<endl;
  cout<<"\tFi_initial_helix_referenceframe (gradi) = "
  <<180.*Fi_initial_helix_referenceframe[nTracksFoundSoFar]/3.14
  <<"\n\tFi_final_helix_referenceframe (gradi) = "
  <<180.*Fi_final_helix_referenceframe[nTracksFoundSoFar]/3.14
  <<", flagStt = "<<flagStt<<endl;

 }
 //------------ fine stampaggi -------------




	if( flagStt == -2 ) continue;	// track outside cylinder RStrawDetectorMax.
	if( flagStt == -1 ) continue;	// track inside cylinder RStrawDetectorMin.
	if( flagStt ==  1 ) continue;	// track comprised in cylinder : discard,
					// because at this stage only tracks from
					// vertex are searched.


//----------------------------------- Bad Tracks rejection :
//-------------  cleanup of the track based on the parallel Stt hits.

//   load auxListHitsinTrack  with the list of parallel hit number (original number,
//   which can be used directly in   info[][]  ).
   for(i=0; i<nHitsinTrack[nTracksFoundSoFar];i++){
     auxListHitsinTrack[i]=infoparal[ ListHitsinTrack[nTracksFoundSoFar][i] ];
   }
	// origin of te track.
	Posiz[0]=Posiz[1]=Posiz[2]=0.;

if(istampa>=3) cout<<"\n\n\nIVOLTE = "<<IVOLTE<<"  and Ntrack = "<< nTracksFoundSoFar<<
 ", prima di cleanup ----------------\n";


	UShort_t &nHits = nHitsinTrack[nTracksFoundSoFar];
	if(YesClean){
	if ( ! (SttParalCleanup(
			VERTICALGAP,
			Ox[nTracksFoundSoFar],
			Oy[nTracksFoundSoFar],
			R[nTracksFoundSoFar],
			Charge[nTracksFoundSoFar],
			Posiz,  // starting point of trajectory.
			nHits, // input and output
			auxListHitsinTrack,  // input and output
			info,
		RStrawDetectorMin,  //this is the  same as the distance hexagon side from (0,0)
			ApotemaMaxInnerParStraw,  //distance hexagon side from (0,0)
			ApotemaMinOuterParStraw,  //distance hexagon side from (0,0)
			RStrawDetectorMax  // Outer Radius containing all the wire positions,
					   // in XY plane, of the Straw Detector.
			) ) )  continue;
	}

//--------------------------- end of cleanup



// --------  here the track and its hits were found, filling the exclusion list

   for(j=0; j<nHitsinTrack[nTracksFoundSoFar]; j++){
     ExclusionList[    infoparal[   ListHitsinTrack[nTracksFoundSoFar][j]  ] ] = false;
   }


//--------------------------------------------------    macro for display

if(iplotta && IVOLTE <= nmassimo){
        WriteMacroParallelHitsConformalwithMCspecial(
                   nHitsinTrack[nTracksFoundSoFar],
                   auxinfoparalConformal,
                   nTracksFoundSoFar,
                   ALFA,
                   BETA,
                   GAMMA,
                   Status[nTracksFoundSoFar], trajectory_vertex
                                                     );
}


//----------------------------------- end macro for display





   nTracksFoundSoFar++;


   if( nTracksFoundSoFar >= MAXTRACKSPEREVENT ){
	cout<<"from PndSttTrackFinderReal :  # n. Tracks found so far = "<<nTracksFoundSoFar
         <<" and it is >= MAXTRACKSPEREVENT ( = "<<MAXTRACKSPEREVENT
	 <<"; rejecting this event and returning !\n";
	return -15;
   }

  }      // end  of   for(iParHit=0; iParHit<Minclinations[0]+1-MINIMUMHITSPERTRACK; iParHit++)



//-----------------------
//-----------------------
//-----------------------
//-----------------------  doing the fit with the skew hits for each XY plane track found
//-----------------------
//-----------------------
//-----------------------

   bool keepit[nTracksFoundSoFar];

  for(i=0; i<nTracksFoundSoFar;i++){

    keepit[i]=true;	// initialization.

    GoodSkewFit[i]=false;  //  flag indicating if the skew sector info has completed the parameter info;
			   //  a priori this is set false.

    nSkewHitsinTrack[i]=0;

    if( Fi_low_limit[i] <-99998.) continue ;  // this is when in XY the Helix circle is not in the
						// STT region; this in principle should never happen.

//-----  finding the skew hits intersecting this XY trajectory circle


  TemporarynSkewHitsinTrack = AssociateSkewHitsToXYTrack(
                   ExclusionListSkew,
                   Ox[i],   //  input : X of center of XY plane circle
                   Oy[i],   //  input : Y of center of XY plane circle
                   R[i],   //  input : Radius of XY plane circle
                   info,
                   inclination,
                   Fi_low_limit[i],// in the Helix XY frame, taking into account the minimum/maximum
                   Fi_up_limit[i], // radius of the STT  detector.
                   Charge[i],
                   Fi_initial_helix_referenceframe[i],
                   Fi_final_helix_referenceframe[i],
                   TemporarySkewList, // output,  list of selected skew hits (in skew numbering)
                   S,       //  output,  S coordinate of selected Skew hit
                   Z,       //  output,  Z coordinate of center wire of selected Skew hit
                   ZDrift,   //  output,  drift distance IN Z DIRECTION only, of selected Skew hit
                   ZErrorafterTilt   //  output,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                                                     );
    nSkewHitsinTrack[i]=TemporarynSkewHitsinTrack;   // it can be also zero!
    for(j=0;j<nSkewHitsinTrack[i];j++){
	ListSkewHitsinTrack[i][j]=TemporarySkewList[j][0];
    }


 //    if( nSkewHitsinTrack[i] < MINIMUMHITSPERTRACK) {
     if( nSkewHitsinTrack[i] < 2) {
	for(j=0;j<nSkewHitsinTrack[i];j++){
		Sfinal[i][infoskew[ ListSkewHitsinTrack[i][j] ]]= S[j];
	}
	continue ;
//        continue;
     }

//  finding if there are discontinuity at 0 for fi value of the Skew Straws Hit.
//  In case of discontinuity at 0, add 2*PI to fi of those hits with fi in the 1st quadrant.
//  This is necessary because the discontinuities would make the fit
//  in the SZ plane fail.
//  In this discontinuity fixing, the value FI0 of the vertex (0,0) is also included.
//  If there is discontinuity fixing, the values of S[i] AND POSSIBLY
//  Fi_initial_helix_referenceframe[i] might be modified (+2.*PI) from  now on.


      FixDiscontinuitiesFiangleinSZplane(
                nSkewHitsinTrack[i],
                S,
                &Fi_initial_helix_referenceframe[i],
                Charge[i]
                                        );


      Status[i] = PndSttFitSZspacebis( 
                nSkewHitsinTrack[i],
                S,
                Z,
                ZDrift,
                Fi_initial_helix_referenceframe[i],   //   this is an input data
                NHITSINFIT,
                &KAPPA[i]
                      );

//    Status[i] is negative (-99) when m = 0. and (-100) as result when the fit with glpk
//		failed.


      if(Status[i] < 0 || fabs(KAPPA[i])>1.e10)  {
	//  necessary to load here the Sfinal  vector anyway.
	for(j=0;j<nSkewHitsinTrack[i];j++){
		Sfinal[i][infoskew[ListSkewHitsinTrack[i][j]]]= S[j];
	}
        continue;
      }

      FI0[i]=Fi_initial_helix_referenceframe[i];  //  therefore, FI0[i] has an extra +2*PI or -2*PI added
						  // in case of tracks
						  //  crossing the X axis




//-----  finding a better association of the skew hits intersecting this XY trajectory circle

//    this means discarding those skew hits that are too far away from the fitted straight line
//    found in the SZ fit.


  NNN=AssociateBetterAfterFitSkewHitsToXYTrack(
		nSkewHitsinTrack[i],
		TemporarySkewList, // input, list of selected skew hits (in skew numbering)
		S,       //  input,  S coordinate of selected Skew hit
		Z,       //  input,  Z coordinate of center wire of selected Skew hit
		ZDrift,   //  input,  drift distance IN Z DIRECTION only, of selected Skew hit
		ZErrorafterTilt,   //  input,  Radius taking into account the tilt,
				   // IN Z DIRECTION only, of selected Skew hit
		KAPPA[i],    // input, KAPPA result of fit
		FI0[i],    // input, FI0 result of fit,
                   tempore,  //  output, associated skew hits
                   temporeS,  //  output, associated skew hit  S
                   temporeZ,  //  output, associated skew hits Zcoordinate of center wire
                   temporeZDrift,  //  output, associated skew hit Z drift
                   temporeZErrorafterTilt,  //  output, associated skew hits Z error after tilt
                   &STATUS   // output
					);
//    out of this function  STATUS  is zero signals only that KAPPA  is zero.




 if( STATUS >=0 ){

       nSkewHitsinTrack[i] = NNN;
       for(j=0;j<nSkewHitsinTrack[i];j++){


		ListSkewHitsinTrack[i][j]=tempore[j];
		Sfinal[i][infoskew[ListSkewHitsinTrack[i][j]]]= temporeS[j];
		S[j]  =  temporeS[j] ;
		Z[j]  =  temporeZ[j] ;
		ZDrift[j]  =  temporeZDrift[j] ;
		ZErrorafterTilt[j]  =  temporeZErrorafterTilt[j] ;
       }

       if (NNN < 2) continue ;

       GoodSkewFit[i]= true;

 }   else {   //   continuation of   if( STATUS >=0 )

    nSkewHitsinTrack[i]=TemporarynSkewHitsinTrack;
    for(j=0;j<TemporarynSkewHitsinTrack;j++){ ListSkewHitsinTrack[i][j]=TemporarySkewList[j][0];}
    GoodSkewFit[i]= true;
 }    //  end of     if( STATUS >=0 )


      if( nHitsinTrack[i]+nSkewHitsinTrack[i] < MINIMUMHITSPERTRACK ||
	 nHitsinTrack[i]+nSkewHitsinTrack[i]>nmaxHitsInTrack) {
	keepit[i]=false;
        continue;
      }



      // ---------    numbering according to the ORIGINAL hit number
    for(i1=0; i1< nSkewHitsinTrack[i]; i1++){
             Sfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  S[i1] ;
             Zfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  Z[i1] ;
             ZDriftfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  ZDrift[i1] ;
             ZErrorafterTiltfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  ZErrorafterTilt[i1] ;
    }
     // ---------


//     -------------------------------------------------------------



   }   //  end of     for(i=0; i<nTracksFoundSoFar;i++)
//------------------------------------------------------  end of skew hits section


// now the   ordering the parallel and skew hits.


   for(i=0; i<nTracksFoundSoFar;i++){
	nTotalHits[i] =  nHitsinTrack[i]+nSkewHitsinTrack[i];
	if ( nSkewHitsinTrack[i]==0) continue;

	PndSttOrderingSkewandParallel(
		infoparal,
		infoskew,
		Ox[i],
		Oy[i],
		R[i],
		nSkewHitsinTrack[i],  // input
		&ListSkewHitsinTrack[i][0],// input, but this gets ordered
		&Sfinal[i][0], // input from Skew Straws
		Charge[i], // input
		nHitsinTrack[i], // input, # parallel Hits in the current track
		&ListHitsinTrack[i][0],	// this was already ordered
		&U[i][0], // U conformal parallel hits; input, this was already ordered
		&V[i][0], // V conformal parallel hits; input, this was already ordered
		&BigList[i][0] // this is the final ordered Parallel+Skew list; already
				// in NATIVE hit number.
				);




if(istampa>=2) 
{
  cout<<"Evt. n. "<<IVOLTE<<", Traccia n. "<<i<<",  list dei "<<nTotalHits[i]
  <<"   hits come stanno in BigList (original notation) :\n";

   for(int ig=0;ig<nTotalHits[i];ig++){
        cout<<"          hit n.  "<<BigList[i][ig] <<endl;
   }
  cout<<"e ora gli skew hits ordinati (original notation) :\n";
   for(int ig=0;ig<nSkewHitsinTrack[i];ig++){
        cout<<"          hit n.  "<<infoskew[ListSkewHitsinTrack[i][ig]] <<endl;
   }
}


   }   //  end of     for(i=0; i<nTracksFoundSoFar;i++)



//------------------  cleanup of tracks based on the Stt Skew hits.

   for(i=0; i<nTracksFoundSoFar;i++){

if(istampa>=2)cout<<"\tprima di Skew cleanup, IVOLTE = "
<<IVOLTE<<",  traccia n. "<<i<<", lista degli hit skew :"<<endl;

	Double_t auxS[nSkewHitsinTrack[i]];
	if(nSkewHitsinTrack[i]==0) continue;

	// the following loop  exploits the ordering previously done.
	for(j=0;j<nSkewHitsinTrack[i];j++){
		auxListHitsinTrack[j]=infoskew[ ListSkewHitsinTrack[i][j] ];
		auxS[j]=Sfinal[i][ infoskew[ ListSkewHitsinTrack[i][j] ] ];
//------------------ stampe.
if(istampa>=2)cout<<"\thit skew (nativo) n. "<<infoskew[ ListSkewHitsinTrack[i][j] ]
<<", X (tubo) "<<info[infoskew[ ListSkewHitsinTrack[i][j] ]][0]
<<", Y (tubo) "<<info[infoskew[ ListSkewHitsinTrack[i][j] ]][1]
<<", FI "<<auxS[j]<<endl
<<"\t\tsuo X calcolato "<<Ox[i]+R[i]*cos(auxS[j])
<<", suo Y calcolato "<<Oy[i]+R[i]*sin(auxS[j])
<<endl;
//------------------- fine stampe.
	}// endo of for(j=0;j<nSkewHitsinTrack[i];j++)


	//  calculate if the last hit is a parallel or skew.
	if( fabs( info[ BigList[i][ nTotalHits[i]-1 ] ][5] -1. ) < 1.e-5 )
		Consider = true;	// last hit is parallel.
	else	Consider = false;


	if(YesClean) {
	if ( ! (SttSkewCleanup(
			VERTICALGAP,
			Ox[i],
			Oy[i],
			R[i],
			Charge[i],
			Posiz,  // strarting point of trajectory.
			nSkewHitsinTrack[i],
			auxS,
			ApotemaMinSkewStraw,  //distance hexagon side from (0,0)
			ApotemaMaxSkewStraw,  //distance hexagon side from (0,0)
			Consider,	// consider (true) or not also distance
					// of last skew hit from Skew boundary.
			2.,
			1
			) ) )  keepit[i] = false;  // otherwise it remains true, as per initialization.
	}
//--------inizio stampe
if(istampa>=2)cout<<"\tdopo di Skew cleanup, IVOLTE = "
<<IVOLTE<<",  traccia n. "<<i<<", lista degli hit skew :"<<endl;
	for(j=0;j<nSkewHitsinTrack[i];j++){
		auxListHitsinTrack[j]=infoskew[ ListSkewHitsinTrack[i][j] ];
		auxS[j]=Sfinal[i][ infoskew[ ListSkewHitsinTrack[i][j] ] ];

if(istampa>=2)cout<<"\thit skew (nativo) n. "<<infoskew[ ListSkewHitsinTrack[i][j] ]
<<", X (tubo) "<<info[infoskew[ ListSkewHitsinTrack[i][j] ]][0]
<<", Y (tubo) "<<info[infoskew[ ListSkewHitsinTrack[i][j] ]][1]
<<", FI "<<auxS[j]<<endl
<<"\t\tsuo X calcolato "<<Ox[i]+R[i]*cos(auxS[j])
<<", suo Y calcolato "<<Oy[i]+R[i]*sin(auxS[j])
<<endl;
	}
//----------------fine stampe.

   }


//------------------  end of  cleanup of tracks based on the Stt Skew hits.


//--------------------  inizio della sezione sul confronto tra MC truth e tracce trovate

//    associate the tracks found with Pattern Recognition to the MC tracks

   for(int ig=0;ig<nTracksFoundSoFar;ig++){
   	daTrackFoundaTrackMC[ig]=-1;	// inizialization for protection agains possible
					// weird values; this is necessary because later
					// this is used in the PndTrackCand array.
   }


   if( nMCTracks >0 && nTracksFoundSoFar > 0  && doMcComparison ) {


         AssociateFoundTrackstoMCbis(
		keepit,
		  info,
                  nTracksFoundSoFar,
                  nHitsinTrack,
                  ListHitsinTrack,
                  nSkewHitsinTrack,
                  ListSkewHitsinTrack,
                  daTrackFoundaTrackMC
                                   );


   for(jexp=0; jexp<nTracksFoundSoFar;jexp++){
	if(!keepit[jexp]) continue;
	nParalCommon[jexp]=0;
	nSkewCommon[jexp]=0;
	nMCParalAlone[jexp]=0;
	nMCSkewAlone[jexp]=0;
	nSpuriParinTrack[jexp]=0;
	nSpuriSkewinTrack[jexp]=0;

// --- parallel hits

	for(exphit=0; exphit<nHitsinTrack[jexp]; exphit++){
		iHit = infoparal[ ListHitsinTrack[jexp][exphit] ];
		enne[jexp][exphit] = (Short_t) ( info[iHit][6] + 0.01);
		if( enne[jexp][exphit] == daTrackFoundaTrackMC[jexp] ){
			ParalCommonList[jexp][ nParalCommon[jexp] ] = iHit;
			nParalCommon[jexp]++;
		} else {
			ParSpuriList[jexp][ nSpuriParinTrack[jexp] ] = iHit;
			nSpuriParinTrack[jexp]++;
		}

	}
//--- ricerca degli hits non mecciati, della traccia MC associata a questa traccia trovata.
	for(i=0; i<Minclinations[0]; i++){
		if( !ExclusionListbis[ infoparal[i] ] ) continue;
		emme = (Short_t) ( info[ infoparal[i] ][6] + 0.01);
		if( emme == daTrackFoundaTrackMC[jexp] ){
			for(exphit=0; exphit<nHitsinTrack[jexp]; exphit++){
				if(ListHitsinTrack[jexp][exphit] == i) goto pinco ;
			}
			MCParalAloneList[jexp][ nMCParalAlone[jexp] ] = infoparal[i];
			nMCParalAlone[jexp]++;
			pinco:  ;
		}
	}  //  end of  for(i=0; i<Minclinations[0]; i++)

	nHitsInMCTrack[jexp] = nMCParalAlone[jexp]+nParalCommon[jexp];
// --- skew hits

	for(exphit=0; exphit<nSkewHitsinTrack[jexp]; exphit++){
		iHit = infoskew[ ListSkewHitsinTrack[jexp][exphit] ];
		enne[jexp][exphit] = (Short_t) ( info[iHit][6] + 0.01);
		if( enne[jexp][exphit] ==   daTrackFoundaTrackMC[jexp] ){
			SkewCommonList[jexp][ nSkewCommon[jexp] ] = iHit;
			nSkewCommon[jexp]++;
		} else {
			SkewSpuriList[jexp][ nSpuriSkewinTrack[jexp] ] = iHit;
			nSpuriSkewinTrack[jexp]++;			
		}

	}

//--- ricerca degli hits non mecciati, della traccia MC associata a questa traccia trovata.
	for(i=0; i<NSkewhits; i++){
		if( !ExclusionListSkewbis[ infoskew[i] ] ) continue;
		emme = (Short_t) ( info[ infoskew[i] ][6] + 0.01);
		if( emme ==   daTrackFoundaTrackMC[jexp] ){
			for(exphit=0; exphit<nSkewHitsinTrack[jexp]; exphit++){
				if(i == ListSkewHitsinTrack[jexp][exphit]) goto pinco2 ;
			}
			MCSkewAloneList[jexp][ nMCSkewAlone[jexp] ] = infoskew[i];
			nMCSkewAlone[jexp]++;
			pinco2:  ;
		}
	}

	nSkewHitsInMCTrack[jexp] = nMCSkewAlone[jexp]+nSkewCommon[jexp];


   }   //   end of  for(jexp=0; jexp<nTracksFoundSoFar;jexp++)







  if(istampa>=1 )  fprintf(HANDLE, "\n Evento %d  NTotaleTracceMC %d ------\n",IVOLTE, nMCTracks);

for (ii=0; ii<nTracksFoundSoFar && istampa>=1 ;ii++){
   if(!keepit[ii]) continue;
   fprintf(HANDLE,"----------------------------------------------------------\n");
   i=daTrackFoundaTrackMC[ii];

   if( i <0  ) {
    fprintf(HANDLE,
"   No TracciaMC associated to found track n. %d in pattern recognition, with %d Hits ||, %d skew hits, %f Radius \n "
             ,ii,nHitsinTrack[ii], nSkewHitsinTrack[ii],  R[ii] );
            continue;
         }
   if( ! ( GoodSkewFit[ii] ) ) {
    fprintf(HANDLE,
"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' in Z-S KAPPA e' risultata || asse S\n",i,ii);
            continue;
         }
   if(fabs(KAPPA[ii])<1.e-10 ){
    fprintf(HANDLE,
"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' KAPPA troppo piccolo; KAPPA = %g\n",
          i,ii,KAPPA[ii]);
           continue;
   } else if (fabs(KAPPA[ii])>1.e-10 ){
    fprintf(HANDLE,
"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' KAPPA troppo grande; KAPPA = %g\n",
          i,ii,KAPPA[ii]);
           continue;
   }
   Double_t dista=sqrt( Ox[ii]*Ox[ii]+Oy[ii]*Oy[ii] );
   if(fabs(dista)<1.e-20 ){
    fprintf(HANDLE,
"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' centro Helix Cilinder trovato dista solo %g da (0,0)\n",
           i,ii,dista);
           continue;
   }
   pMCtr = (PndMCTrack*) fMCTrackArray->At(i);
   if ( ! pMCtr ){
		fprintf(HANDLE,
		"       MC track n. %d doesn't have pointer to MC Track TClones Array\n",
		i);
	  continue;
   }


    fprintf(HANDLE,
"       TracciaMC %d ParHitsMC %d ParMecc %d ParMeccSpuri %d SkewHitsMC %d  SkewMecc %d SkewMeccSpuri %d\n",
             i,
             nHitsInMCTrack[ii],
             nParalCommon[ii],
             nSpuriParinTrack[ii],
             nSkewHitsInMCTrack[ii],
             nSkewCommon[ii],
             nSpuriSkewinTrack[ii]

           )  ;
    fprintf(HANDLE,
"       e corrisponde a track found n. %d\n", ii );
    fprintf(HANDLE,
"       AVENDO %d hits paralleli e %d hits skew non mecciati dalla corrisponde track found\n"
       , nMCParalAlone[ii],nMCSkewAlone[ii]  );

    HoughFi = atan2(Oy[ii],Ox[ii]);
    if(HoughFi<0.)  HoughFi += 2.*PI;

         Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy  ;
         Int_t icode;
         icode  = pMCtr->GetPdgCode() ;    //   PDG code of track
         Oxx = pMCtr->GetStartVertex().X();    //   X of starting point track
         Oyy = pMCtr->GetStartVertex().Y();    //   Y of starting point track
         Px = pMCtr->GetMomentum().X();
         Py = pMCtr->GetMomentum().Y();
         aaa = sqrt( Px*Px + Py*Py);
         Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
         if (icode>1000000000) carica = 1.;
         else  carica = fParticle->Charge()/3. ;    //   charge of track
         Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
         Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
         Fifi = atan2(Cy, Cx);       // MC truth Fifi angle of circle of Helix trajectory
         if(Fifi<0.)  Fifi += 2.*PI;
         Double_t Kakka ;
         if( fabs( pMCtr->GetMomentum().Z() )< 1.e-20) Kakka = 99999999.;
         else  Kakka = -carica*0.001*BFIELD*CVEL/pMCtr->GetMomentum().Z();

    fprintf(HANDLE,
"       R_MC %g R %g Fi_MC %g Fi %g KAPPA_MC %g KAPPA %g FI0_MC %g FI0 %g\n",
     Rr,
     R[ ii ],
     Fifi,
     HoughFi,
     Kakka,
     KAPPA[ ii ],
     fmod(Fifi+ PI, 2.*PI),  //  FI0  da MC truth
     FI0[ ii ]
           );
     

  }   //   end of  for (ii=0; ii<nTracksFoundSoFar && istampa>=2 ;ii++)


//--------------ghosts

if( istampa>=2){
    int NParghost=0, NParhitsghost=0,icc;
    for(icc=0; icc<nTracksFoundSoFar;icc++){
	if(!keepit[icc]) continue;
       if( daTrackFoundaTrackMC[icc] == -1){
          NParghost++;
          NParhitsghost += nHitsinTrack[icc]+nSkewHitsinTrack[icc];

          fprintf(HANDLE,"          tracce Trovata n. %d e' Ghost\n",icc);
       }
    }
    fprintf(HANDLE,
"          tracceGhostTrovate %d TotaleHitsGhost %d  ----\n",
            NParghost,
            NParhitsghost
           );

    fprintf(HANDLE,"----------------------------------------------------------\n");

}  //   end of    if( istampa>=2)



	}  //  end of  if( nMCTracks >0 && nTracksFoundSoFar > 0  && doMcComparison )

//--------------------  fine della sezione sul confronto tra MC truth e tracce trovate





//---------------------------------------------------------------------------------------------------------
//   loading the hits found and associated to a track in a  PndTrackCand  class; a class per each track

	int   ipinco=0, ipanco=0;
	Int_t flag;
	Double_t Ptras,Pxini,Pyini,Pzini,dista, qop;
	PndTrackCand *pTrckCand;
	PndTrack*     pTrck; 
	TVector3   Momentum,ErrMomentum,Position,ErrPosition;
    for(i=0; i<nTracksFoundSoFar;i++){
	if(!keepit[i]) continue;
       dista=sqrt( Ox[i]*Ox[i]+Oy[i]*Oy[i] );
       Ptras = R[i]*0.003*BFIELD;
       Pxini = -Charge[i]*Ptras*Oy[i]/dista;
       Pyini = Charge[i]*Ptras*Ox[i]/dista;
       TVector3 posSeed(0.,0.,0.);  //  the starting point of the trajectory

     if(   GoodSkewFit[i]  ) {
       new((*trackCandArray)[ipinco])  PndTrackCand;
       pTrckCand = (PndTrackCand*) trackCandArray->At(ipinco);

       if(fabs(KAPPA[i])>1.e-20  ){
		Pzini = -Charge[i]*0.003*BFIELD/KAPPA[i];
		// PMAX is the maximum Pz tolerable; it is set at 100 for now.
		if(fabs(Pzini) < PMAX)  flag =0 ; else flag=-1;
		TVector3 dirSeed(Pxini,
			   Pyini,
			   Pzini); // momentum direction in starting point
		qop = Charge[i]/dirSeed.Mag();
		dirSeed.SetMag(1.);

		pTrckCand->setTrackSeed(posSeed, dirSeed, qop);
		pTrckCand->setMcTrackId(  daTrackFoundaTrackMC[i]   );
		for(j=0; j< nTotalHits[i]; j++){
			pTrckCand->AddHit(
			FairRootManager::Instance()->GetBranchId(fSttBranch),
			(Int_t) BigList[i][j] , j);
		}

	//--------  do relevant calculation for this track and load the PndTrack  class
	//---- first hit
		if(fabs(info[ BigList[i][0] ][5] -1.)< 1.e-10 ) {// it is a parallel straw
			PndSttInfoXYZParal(
                             info,
                             BigList[i][0],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz1
                           );
		} else {					//   it is a skew straw
			PndSttInfoXYZSkew(
                             Zfinal[i][ BigList[i][0] ],       //  Z coordinate of selected Skew hit
                             ZDriftfinal[i][ BigList[i][0] ],   // drift distance IN Z DIRECTION only, of Skew hit
                             Sfinal[i][ BigList[i][0] ],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz1
                            );
		}
		//  if all X, Y, Z positions were found for the first hit, go on
		if( Posiz1[0] > -777777776. )
		{
			//---- last hit
			if(fabs(info[ BigList[i][nTotalHits[i]-1] ][5] -1.)< 1.e-10 ) {// it is a parallel straw
				PndSttInfoXYZParal (
						info,
						BigList[i][nTotalHits[i]-1],
						Ox[i],
						Oy[i],
						R[i],
						KAPPA[i],
						FI0[i],
						Charge[i],
						Posiz2
						);
			} else {					//   it is a skew straw
				PndSttInfoXYZSkew (
                             Zfinal[i][ BigList[i][nTotalHits[i]-1] ],       //  Z coordinate of selected Skew hit
                             ZDriftfinal[i][ BigList[i][nTotalHits[i]-1] ],   // drift distance IN Z DIRECTION only, of Skew hit
                             Sfinal[i][ BigList[i][nTotalHits[i]-1] ],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz2
                            );
			}
			if( Posiz2[0] > -777777776.  )
			{

				// load in   FairTrackParP first  the relevant quantities
				// of the first hit
				Position.SetX( Posiz1[0] );
				Position.SetY( Posiz1[1] );
				Position.SetZ( Posiz1[2] );
				ErrPosition.SetX(0.02);	// 200 microns
				ErrPosition.SetY(0.02);	// 200 microns
				ErrPosition.SetZ(1.);		// 1 cm
				// calculate Px and Py
				versor[0] = Ox[i]-Posiz1[0];
				versor[1] = Oy[i]-Posiz1[1];
				Distance = sqrt(versor[0]*versor[0]+versor[1]*versor[1]);
			// I already know from PndSttInfoXYZ... that versor is not zero.
				versor[0] /= Distance;
				versor[1] /= Distance;
				Px = -Charge[i]*Ptras*versor[1];
				Py = Charge[i]*Ptras*versor[0];
				Momentum.SetX(Px);
				Momentum.SetY(Py);
				Momentum.SetZ(Pzini);
				ErrMomentum.SetX(0.05*Ptras); //  set at 5% all the times.
				ErrMomentum.SetY(0.05*Ptras); //  set at 5% all the times.
				ErrMomentum.SetZ(0.05*Pzini); //  set at 5% all the times.
				//  the plane of this FairTrackParP better is perpendicular to
				//  the momentum direction
				ddd = Ptras*sqrt(Ptras*Ptras+Pzini*Pzini);
				FairTrackParP first( Position,  Momentum,
					ErrPosition, ErrMomentum, Charge[i],
//					Position, TVector3(1., 0., 0.), TVector3(0., 1., 0.)
//						);
					Position, TVector3(Py/Ptras, -Px/Ptras, 0.),
					TVector3(Pzini*Px/ddd,Pzini*Py/ddd, -Ptras*Ptras/ddd)
							);
				// load in   FairTrackParP first  the relevant quantities
				// of the last hit
				Position.SetX( Posiz2[0] );
				Position.SetY( Posiz2[1] );
				Position.SetZ( Posiz2[2] );
				ErrPosition.SetX(0.02);	// 200 microns
				ErrPosition.SetY(0.02);	// 200 microns
				ErrPosition.SetZ(1.);		// 1 cm
				// calculate Px and Py
				versor[0] = Ox[i]-Posiz2[0];
				versor[1] = Oy[i]-Posiz2[1];
				Distance = sqrt(versor[0]*versor[0]+versor[1]*versor[1]);
			// I already know from PndSttInfoXYZ... that versor is not zero.
				versor[0] /= Distance;
				versor[1] /= Distance;
				Px = -Charge[i]*Ptras*versor[1];
				Py = Charge[i]*Ptras*versor[0];
				Momentum.SetX(Px);
				Momentum.SetY(Py);
				// Momentum.SetZ(Pzini);
				ErrMomentum.SetX(0.05*Ptras); //  set at 5% all the times.
				ErrMomentum.SetY(0.05*Ptras); //  set at 5% all the times.
				// ErrMomentum.SetZ(0.05*Pzini); //  set at 5% all the times.
				//  the plane of this FairTrackParP better is perpendicular to
				//  the momentum direction
				FairTrackParP last( Position,  Momentum,
				ErrPosition, ErrMomentum, Charge[i],
				Position, TVector3(Py/Ptras, -Px/Ptras, 0.),
					TVector3(Pzini*Px/ddd,Pzini*Py/ddd, -Ptras*Ptras/ddd)
						);
				//--------   load PndTrack object
				pTrck = new((*trackArray)[ipanco]) PndTrack(first, last, *pTrckCand);
				pTrck->SetRefIndex(ipanco);
				pTrck->SetFlag(flag);  // at this point flag = 0 for Pz<PMAX, -1 otherwise.
				ipanco++;

			}  else { // continuation  of  if( Posiz2[0]>-777777776.)
				//case of something wrong with last hit
				FairTrackParP first(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
						);
				FairTrackParP last(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
						);
				//--------   load PndTrack object
				pTrck = new((*trackArray)[ipanco]) PndTrack(first, last, *pTrckCand);
				pTrck->SetRefIndex(ipanco);
				pTrck->SetFlag(-1);
				ipanco++;

			}   // end of if( Posiz2[0]>-777777776. )

		}  else { // continuation of  if( Posiz1[0] > -777777776.)
			//case of something wrong with first hit
			FairTrackParP first(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
						);
				FairTrackParP last(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
						);
			//--------   load PndTrack object
			pTrck = new((*trackArray)[ipanco]) PndTrack(first, last, *pTrckCand);
			pTrck->SetRefIndex(ipanco);
			pTrck->SetFlag(-1);
			ipanco++;
		}	// end of  if( Posiz1[0] > -777777776.)


       } else {	//   continuation of   if(fabs(KAPPA[i])>1.e-20  )

		Pzini = 999999.;
		TVector3 dirSeed(Pxini,
			   Pyini,
			   Pzini); // momentum direction in starting point
		qop = Charge[i]/dirSeed.Mag();
		dirSeed.SetMag(1.);

		pTrckCand->setTrackSeed(posSeed, dirSeed, qop);
		pTrckCand->setMcTrackId(  daTrackFoundaTrackMC[i]   );
		for(j=0; j< nTotalHits[i]; j++){
			pTrckCand->AddHit(
//			FairRootManager::Instance()->GetBranchId("STTHit"),
			FairRootManager::Instance()->GetBranchId(fSttBranch),
			(Int_t) BigList[i][j] , j);
		}


		// load dummy quantities in PndTrack
		FairTrackParP first(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
				);
		FairTrackParP last(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
				);
		//--------   load PndTrack object
		pTrck = new((*trackArray)[ipanco]) PndTrack(first, last, *pTrckCand);
		pTrck->SetRefIndex(ipanco);
		pTrck->SetFlag(-1);
		ipanco++;



       }	// end of  if(fabs(KAPPA[i])>1.e-20  )



      }   else  { //   continuation of    if(   GoodSkewFit[i]  )   //  case in which there is no
                                                                    //  skew hits in this track.
								    //  This fact is signalled by
         Pzini = 9999.;
         new((*trackCandArray)[ipinco])  PndTrackCand;
         pTrckCand = (PndTrackCand*) trackCandArray->At(ipinco);
	 TVector3 dirSeed(Pxini,
			Pyini,
			Pzini); // momentum direction in starting point
         qop = Charge[i]/Ptras;   //  as if Pz=0


//          dirSeed.SetMag(1.);
         pTrckCand->setTrackSeed(posSeed, dirSeed, qop);
         pTrckCand->setMcTrackId(  daTrackFoundaTrackMC[i]   );
         for(j=0; j< nTotalHits[i]; j++){

               pTrckCand->AddHit(
//		FairRootManager::Instance()->GetBranchId("STTHit"),
		FairRootManager::Instance()->GetBranchId(fSttBranch),
		(Int_t) BigList[i][j] , j);
         }


	// load dummy quantities in PndTrack
	FairTrackParP first(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
			);
	FairTrackParP last(
					TVector3(-99999., -99999., -99999.), //  dummy Position
					TVector3(-99999., -99999., -99999.), //  dummy Momentum
					TVector3(-99999., -99999., -99999.), //  dummy ErrPosition
					TVector3(-99999., -99999., -99999.), //  dummy ErrMomentum
					0, //  dummy Charge
					TVector3(-99999., -99999., -99999.), //  dummy Position again
					TVector3(1., 0., 0.), //  dummy direction versor
					TVector3(0., 1., 0.) //  dummy direction versor
			);
	//--------   load PndTrack object
	pTrck = new((*trackArray)[ipanco]) PndTrack(first, last, *pTrckCand);
	pTrck->SetRefIndex(ipanco);
	pTrck->SetFlag(-1);
	ipanco++;



      }    //   end of      if(   GoodSkewFit[i]  )









//--- now increment the : number of PndTrackCand counter

         ipinco++;

    }   //  end of     for(i=0; i<nTracksFoundSoFar;i++)







//---------------   printouts of comparison with MC for judging algorithm performance




   if( nMCTracks >0 && nTracksFoundSoFar > 0  && doMcComparison ) {


    for(i=0; i<nTracksFoundSoFar;i++){
       if(!GoodSkewFit[i])   continue;
	if(!keepit[i]) continue;

    for( j=0; j<nParalCommon[i]; j++){

       PndSttInfoXYZParal (
                             info,
                             ParalCommonList[i][j],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz
                                  );

if(istampa>=2)  cout<<"DoFind, paralleli, n. hits (original notation) = "<<
       ParalCommonList[i][j] <<
       ", X = "<<
       Posiz[0]<<
       ", Y = "<<
       Posiz[1]<<
       ", Z = "<<
       Posiz[2]<<endl;


if(istampa>=2){
	if( info[ParalCommonList[i][j]][6]<0. ){
		fprintf(PHANDLEX,"Noise hit\n");
		fprintf(PHANDLEY,"Noise hit\n");
		fprintf(PHANDLEZ,"Noise hit\n");
	} else {
		fprintf(PHANDLEX,"%g\n", veritaMC[ ParalCommonList[i][j] ] [0] - Posiz[0]);
		fprintf(PHANDLEY,"%g\n", veritaMC[ ParalCommonList[i][j] ] [1] - Posiz[1]);
		fprintf(PHANDLEZ,"%g\n", veritaMC[ ParalCommonList[i][j] ] [2] - Posiz[2]);
	}
}



         }  //   end of for( j=0; j<nParalCommon[i]; j++)


    for( j=0; j<nSkewCommon[i]; j++){

       PndSttInfoXYZSkew(
                             Zfinal[i][ SkewCommonList[i][j] ],       //  Z coordinate of selected Skew hit
                             ZDriftfinal[i][ SkewCommonList[i][j] ],   // drift distance IN Z DIRECTION only, of Skew hit
                             Sfinal[i][ SkewCommonList[i][j] ],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz
                            );
if(istampa>=2)  cout<<"DoFind, skew, n. hits (original notation) = "<<
       SkewCommonList[i][j] <<
       ", X = "<<
       Posiz[0]<<
       ", Y = "<<
       Posiz[1]<<
       ", Z = "<<
       Posiz[2]<<endl;


if(istampa>=2){
	if( info[SkewCommonList[i][j]][6]<0. ){
		fprintf(SHANDLEX,"Noise hit\n");
		fprintf(SHANDLEY,"Noise hit\n");
		fprintf(SHANDLEZ,"Noise hit\n");
	} else {
		fprintf(SHANDLEX,"%g\n", veritaMC[ SkewCommonList[i][j] ] [0] - Posiz[0]);
		fprintf(SHANDLEY,"%g\n", veritaMC[ SkewCommonList[i][j] ] [1] - Posiz[1]);
		fprintf(SHANDLEZ,"%g\n", veritaMC[ SkewCommonList[i][j] ] [2] - Posiz[2]);
	}
}

         }  //   end of for( j=0; j<nSkewCommon[i]; j++)




	}   //  end of     for(i=0; i<nTracksFoundSoFar;i++)

   }  //  end of  if( nMCTracks >0 && nTracksFoundSoFar > 0  && doMcComparison )

//---------------  end of printouts of comparison with MC for judging algorithm performance

//---------------------------------------------------------------------------------------------------------






//------------------------------------- macro di display.

if(iplotta && IVOLTE <= nmassimo){



//--------------------------------------------------    macro for display

//------
//----------------fine stampa
        WriteMacroParallelHitsGeneral(
		keepit,
                   Nhits, info, Nincl, Minclinations,
		    inclination,nTracksFoundSoFar,TypeConf,ALFA,BETA,GAMMA
                                                     );

//----------------------------------- end macro for display


  if(doMcComparison) {
        WriteMacroParallelHitsGeneralConformalwithMC(
		keepit,
                   Nhits, info, Nincl, Minclinations,
		    inclination,nTracksFoundSoFar,TypeConf,ALFA,BETA,GAMMA
                                                     );


	for(i=0, ii=-1; i<nTracksFoundSoFar;i++){


		if(!keepit[i])continue;
		ii++;

           WriteMacroParallelAssociatedHits(
                   Ox[i], Oy[i], R[i],
                   nHitsinTrack[i],ListHitsinTrack,
                   info, Nincl, Minclinations, inclination,
                   i,
		   ii
                                                     );

           WriteMacroParallelAssociatedHitswithMC(
                   Ox[i], Oy[i], R[i],
		   daTrackFoundaTrackMC[i],
                   nHitsinTrack[i],
		ListHitsinTrack,
                   info,
                   i,
		   ii,
		nParalCommon,
		ParalCommonList,
		nSpuriParinTrack,
		ParSpuriList,
		nMCParalAlone,
		MCParalAloneList
                                                     );
	} // end of for(i=0, ii=-1; i<nTracksFoundSoFar;i++)
  }	// end of if(doMcComparison) 

for(i=0,ii=-1; i<nTracksFoundSoFar;i++){
	if(!keepit[i]) continue;
	ii++;
   if( iplotta) {


    HoughR = R[i];
    HoughD   = sqrt(Ox[i]*Ox[i]+
                                    Oy[i]*Oy[i]) -R[i];
    HoughFi = atan2(Oy[i],Ox[i]);
    if(HoughFi<0.)  HoughFi += 2.*PI;


             WriteMacroSkewAssociatedHits(
		GoodSkewFit[i],
                   KAPPA[i],FI0[i], HoughD, HoughFi, HoughR,
                   info, Nincl,Minclinations,inclination,
                   i,
		   ii,
                   nSkewHitsinTrack[i],
                   ListSkewHitsinTrack

                                                     );
   if(doMcComparison) {
      if( daTrackFoundaTrackMC[i] >= 0){
             WriteMacroSkewAssociatedHitswithMC(
		GoodSkewFit[i],
                   KAPPA[i],FI0[i], HoughD, HoughFi, HoughR,
                   info, Nincl,Minclinations,inclination,
                   i,
		   ii,
                   nSkewHitsinTrack[i],
                   ListSkewHitsinTrack,
                   nSkewCommon[i],
                   SkewCommonList,
                   daTrackFoundaTrackMC[i],
		nMCSkewAlone,
		MCSkewAloneList
                                                     );
      }
   }

   }    //  end of   if (iplotta)
}     //   end of  for(i=0; i<nTracksFoundSoFar;i++)


}   // end of if(iplotta && IVOLTE <= nmassimo)

//------------------------------------- fine macro di display delle skew








  return   nTracksFoundSoFar;


 }; //-------------------------------------------------  end of function  PndSttTrackFinderReal::DoFind








CalculatedCircles PndSttTrackFinderReal::PndSttTrkFindCircles(Double_t x1,Double_t y1,Double_t r1,
                                                 Double_t x2,Double_t y2,Double_t r2,
                                                 Double_t x3,Double_t y3,Double_t r3)
{
  Double_t a,b,c,d,ap,bp,cp,dp,radix,solution,Radius, A,B,C,D,AAA,BBB,CCC,DELTA,S,T,X;
  Int_t Nsol = 0;
  Double_t R[8],CX[8],CY[8];
  CalculatedCircles Ris ;

//cout<<"---------------------------------- inizio printout da find_circles \n";


/*
  x1 = X center crf 1;
  y1 = Y center crf 1;
  r1 = radius crf 1;
  x2 = X center crf 2;
  y2 = Y center crf 2;
  r2 = radius crf 2;
  x3 = X center crf 3;
  y3 = Y center crf 3;
  r3 = radius crf 3;
*/

  a=2.*(x1-x2);
  b=2.*(y1-y2);
  d= x1*x1+y1*y1-r1*r1-x2*x2-y2*y2+r2*r2;
  ap=2.*(x1-x3);
  bp=2.*(y1-y3);
  dp= x1*x1+y1*y1-r1*r1-x3*x3-y3*y3+r3*r3;

/*
cout<<"printout iniziale :\nx1="<<x1<<";\nx2="<<x2<<";\nx3="<<x3<<";\ny1="<<y1<<";\ny2="<<y2<<";\ny3="
       <<y3<<";\nr1="<<r1<<";\nr2="<<r2<<";\nr3="<<r3<<endl;
cout<<" a= "<<a<<";  b="<<b<<";  d="<<d<<endl;
cout<<" ap= "<<ap<<";  bp="<<bp<<";  dp="<<dp<<endl;
cout<<"fine printout iniziale\n";
*/

  Double_t aaa= a*bp-b*ap;
//cout<<"aaa  : "<<aaa<<endl;
  if ( aaa == 0.) {
   for(Int_t i1=-1;i1<=1;i1+=2){
    for(Int_t i2=-1;i2<=1;i2+=2){
      c=-2.*(i1*r1-i2*r2);
      for(Int_t i3=-1;i3<=1;i3+=2){
        cp=-2.*(i1*r1-i3*r3);
        if( bp*c-b*cp == 0. && b == 0. && bp == 0. && a != 0. && ap != 0. && a != ap && ap*c-a*cp != 0.){
           Radius = (a*dp-ap*d)/(ap*c-a*cp);
           if ( Radius >0.){
             S = d/a;
             T = -c/a;
             BBB = y1;
             CCC = (S-T*Radius)*(S-T*Radius)-Radius*Radius-2.*x1*(S-T*Radius)-2.*i1*Radius*r1+x1*x1+y1*y1-r1*r1;
             DELTA = BBB*BBB-CCC;
             if(DELTA<0.) {
              continue;
             } else if (DELTA ==0.){
              Nsol++;
              R[Nsol-1] = Radius ;
              CX[Nsol-1] = S-T*Radius;
              CY[Nsol-1] = -BBB;
             } else{
              Nsol+=2;
              R[Nsol-2] = Radius ;
              CX[Nsol-2] = S-T*Radius;
              CY[Nsol-2] = -BBB+sqrt(DELTA);
              R[Nsol-1] = Radius ;
              CX[Nsol-1] = S-T*Radius;
              CY[Nsol-1] = -BBB-sqrt(DELTA);
             }

           }  //  end  if ( Radius >0.)
        }  else if(bp*c-b*cp != 0.) {

         Radius = (-bp*d+b*dp)/(bp*c-b*cp) ;
         if( Radius > 0. && b != 0. ){
           S = (d+c*Radius)/b;
           T = a/b;
           AAA = 1+T*T;
           BBB = -(T*S+x1-T*y1);
           CCC = S*S-Radius*Radius-2.*y1*S-2.*i1*r1*Radius+x1*x1+y1*y1-r1*r1;
           DELTA= BBB*BBB-AAA*CCC;
//cout<<"AAA ="<<AAA<<",  BBB= "<<BBB<<", CCC ="<<CCC<<", DELTA= "<<DELTA<<endl;
//cout<<"S = "<<S<<", T= "<<T<<endl<<"DELTA "<<DELTA<<endl;
           if(DELTA<0.) {
            continue;
           } else if (DELTA ==0.){
             Nsol++;
             R[Nsol-1] = Radius ;
             CX[Nsol-1] = -BBB/AAA;
             CY[Nsol-1] = S-T*CX[Nsol-1];
// cout<<"CX[Nsol-1] ="<<CX[Nsol-1]<<",  CY[Nsol-1]= "<<CY[Nsol-1]<<endl;
           } else {
             Nsol+=2;
             R[Nsol-2] = Radius ;
             CX[Nsol-2] = (-BBB+sqrt(DELTA))/AAA;
             CY[Nsol-2] = S-T*CX[Nsol-2];
             R[Nsol-1] = Radius ;
             CX[Nsol-1] = (-BBB-sqrt(DELTA))/AAA;
             CY[Nsol-1] = S-T*CX[Nsol-1];
//cout<<"CX[Nsol-2] ="<<CX[Nsol-2]<<",  CY[Nsol-2]= "<<CY[Nsol-2]<<endl;
//cout<<"CX[Nsol-1] ="<<CX[Nsol-1]<<",  CY[Nsol-1]= "<<CY[Nsol-1]<<endl;
           }  // end  if(DELTA<0.)
         }   //  end  if( Radius > 0. && b != 0. )
       }    //   end if( bp*c-b*cp == 0.) 
      }    //  end for (Int_t i3
    }    //  end for(Int_t i2
   }   //  end for(Int_t i1

  } else {   // of if(aaa == 0. )

   A=(bp*d-b*dp)/aaa;
   C=(-ap*d+a*dp)/aaa;
// cout<<"aaa "<<aaa<<endl<<"A "<<A<<endl<<"C "<<C<<endl;
   for(Int_t i1=-1;i1<=1;i1+=2){
    for(Int_t i2=-1;i2<=1;i2+=2){
      c=-2.*(i1*r1-i2*r2);
      for(Int_t i3=-1;i3<=1;i3+=2){
        cp=-2.*(i1*r1-i3*r3);
// cout<<"----------------------------------------\n";
// cout<<"c="<<c<<";  cp="<<cp<<endl;

        B=(bp*c-b*cp)/aaa;
        D=(-ap*c+a*cp)/aaa;

        AAA = B*B+D*D-1.;
        BBB = A*B+C*D-B*x1-D*y1-i1*r1;
        CCC = A*A+C*C-2.*x1*A-2.*y1*C+x1*x1+y1*y1-r1*r1;
        DELTA = BBB*BBB - CCC*AAA;
//        cout<<"caso con i1= "<<i1<<", i2, i3 = "<<" "<<i2<<" "<<i3<<endl
//              <<"A "<<A<<";  B = "<<B<<"; C= "<<C<<"; D = "<<D<<endl;
//        cout<<"AAA = "<<AAA<<";  BBB = "<<BBB<<" DELTA "<<DELTA<<endl;
//        cout<<"sqrt(DELTA) = "<<sqrt(DELTA)<<endl;

        if (DELTA <0.) { continue; }
        else if (DELTA==0.){
         if( BBB==0. ){
          continue;
         } else {
           solution=-BBB/AAA;
           if(solution > 0.){
           Nsol++;
           R[Nsol-1] = solution;
             CX[Nsol-1] = A+B*R[Nsol-1];
             CY[Nsol-1] = C+D*R[Nsol-1];
           }
         continue;
        }
       }

//  this is the case when DELTA > 0.

        radix = sqrt(DELTA);

        if (AAA == 0.) {
          cout<<"AAA== 0.";
          continue;
        } else {

          solution=(-BBB+radix)/AAA;
//cout<<"-BBB[j]  radix  AAA[j] : "<<-BBB <<";  "<< radix <<"; "<< AAA<<"; solution=+ :"<<solution<<endl;
          if(solution > 0.){
           Nsol++;
           R[Nsol-1] = solution;
           CX[Nsol-1] = A+B*R[Nsol-1];
           CY[Nsol-1] = C+D*R[Nsol-1];
          }


          solution=(-BBB-radix)/AAA;
//cout<<"-BBB[j]  radix  AAA[j] : "<<-BBB <<";  "<< radix <<"; "<< AAA<<"; solution=- :"<<solution<<endl;
          if(solution > 0.){
           Nsol++;
           R[Nsol-1] = solution;
           CX[Nsol-1] = A+B*R[Nsol-1];
           CY[Nsol-1] = C+D*R[Nsol-1];
          }



        }     //  end of   if(AAA == 0.)


      }    //  end  for(i3
    }     //  end  for(i2
   }     //  end  for(i1
    


  }   // end if ( aaa == 0.)




//cout<<"----------------------------------------\n";
//  cout<<"n. soluzioni : "<<Nsol<<endl;
 Ris.Ncircles=Nsol;
 for(Int_t i=0; i<Nsol;i++){
//  cout<<"Soluzione n. "<<i+1<<"; R = "<<R[i]<<", CX = "<<CX[i]<<", CY = "<<CY[i]<<endl;
  Ris.CX[i]=CX[i];
  Ris.CY[i]=CY[i];
  Ris.R[i] =R[i];
 }



 return Ris;  

}

//----------------------------------------------------   end of function  PndSttTrackFinderReal::PndSttTrkFindCircles


//----------------------------------------------------   begin function  PndSttTrackFinderReal::PndSttTrkFindHelix

 CalculatedHelix PndSttTrackFinderReal::PndSttTrkFindHelix(
      Double_t Ox, Double_t Oy, Double_t R,
      Double_t Zcenter1,Double_t Zcenter2,Double_t Zcenter3,
      Double_t semilengthStraight1, Double_t semilengthStraight2, Double_t semilengthStraight3,
      Double_t C0x1, Double_t C0y1, Double_t C0z1, Double_t semilengthSkew1,
      Double_t r1, Double_t vx1, Double_t vy1, Double_t vz1,
      Double_t C0x2, Double_t C0y2, Double_t C0z2, Double_t semilengthSkew2,
      Double_t r2, Double_t vx2, Double_t vy2, Double_t vz2,
      Int_t *STATUS
                                                         )
{


//-------------------------------------------



/*
 INPUTS :

  Ox, Oy        = abscissa and ordinate of the center of the circular trajectory of
                  the particle;
  R             = radius of such trajectory;
  C0x, C0y, Coz = x, y, z coordinates of a point belonging to the axis of the
                  skewed straw;
  r  = radius of equidrift of such skewed straw;
  vx, vy, vz    =  versor of the direction along which the skewed straw lies.


 OUTPUTS :

  P1x, P1y, P1z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (first
                    solution);
  P2x, P2y, P2z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (second
                    solution);

*/

  Int_t  Nsolutions, NTOTAL,  Msol, i, j, i1, i2, k1, k2,  enne, jtemp, nfile;

  Double_t aaa, bbb, ccc, ddd, eee, fff,
           bp, cp, bs, cs,
           q1, q2pos, q2neg,
           Rx, Ry, SkewInclWithRespectToS, Aellipsis1, Bellipsis1, Aellipsis2, Bellipsis2, LL,
           alpha, beta, gamma, delta, epsilon,DELTA, A, B, C, D, cosalfa1, cosalfa2,
           alpha1, beta1, gamma1,
           x0, y0, fi1, fi2,
           SSS1, SSS2,
           xmin,xmax,ymin,ymax,
           x1,x2,y1,y2,
           POINTS1[6],POINTS2[6],distance1[2], distance2[2],
           M[4], Temp[4], Tiltdirection1[2], Tiltdirection2[2] ;

//  const Double_t PI = 3.141592654;

  bool BAD1[2], BAD2[2] ;

  char nome[300];

  CalculatedHelix  Result;

//--------------------------



//       cout<<"Entra in PndSttTrkFindHelix.........\n";



 ntimes++;


 aaa = sqrt(vx1*vx1+vy1*vy1+vz1*vz1);
 vx1 /= aaa;
 vy1 /= aaa;
 vz1 /= aaa;
 aaa = sqrt(vx2*vx2+vy2*vy2+vz2*vz2);
 vx2 /= aaa;
 vy2 /= aaa;
 vz2 /= aaa;


 NTOTAL=0;
 Result.Nhelix[0] = Result.Nhelix[1] = Result.Nhelix[2] = 0;

//  calculation of the intersection points between skew straw axis and trajectory cylinder ----------------------------

 calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,r1,vx1,vy1,vz1, STATUS,POINTS1);

 if(*STATUS < 0 ) { return Result;}

 for( i=0; i<2; i++){
  j=3*i;
  distance1[i] = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                 );
  if( distance1[i] >= semilengthSkew1 ){
     BAD1[i] = true ;
  } else {
     BAD1[i]= false ;
  }
 }

//----------------

  if ( BAD1[0]  && BAD1[1] ) {
    *STATUS = -4;
    return Result;
  }

//----------------

 calculateintersections(Ox,Oy,R,C0x2,C0y2,C0z2,r2,vx2,vy2,vz2, STATUS,POINTS2);
 if(*STATUS < 0 ) { return Result;}

//-------------------------
 for( i=0; i<2; i++){
  j=3*i;
  distance2[i] = sqrt(
                  (POINTS2[j]-C0x2)*(POINTS2[j]-C0x2) +
                  (POINTS2[1+j]-C0y2)*(POINTS2[1+j]-C0y2) + 
                  (POINTS2[2+j]-C0z2)*(POINTS2[2+j]-C0z2) 
                 );

  if( distance2[i] >= semilengthSkew2 ){
     BAD2[i] = true ;
  } else {
     BAD2[i]= false ;
  }
 }
//-------------------------

  if ( BAD2[0] && BAD2[1] ) {
    *STATUS = -5;
    return Result;
  }

//---------------------------------------------------------------------------------------------------------------------


for(k1=0; k1<2;k1++){
//              if( BAD1[k1] )  { cout<<"per k1 = "<<k1<<"  la intersezione e' BAD\n";}
 if( BAD1[k1] )  continue;
 i1 = 3*k1;

//  calculation of the approximate axis length of the ellipses projection of the skew straw on the plane tangent to the trajectory cylinder.
//  first skew straw

 Rx = POINTS1[i1]-Ox ;   //  x component Radial vector of cylinder of trajectory
 Ry = POINTS1[1+i1]-Oy ;   //  y direction Radial vector of cylinder of trajectory

 aaa = sqrt(Rx*Rx+Ry*Ry);
 SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
  SkewInclWithRespectToS /= R;
 bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
//  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
 if( bbb > 1.e-10){
   Tiltdirection1[0] = vz1/bbb;
   Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
 } else {
   Tiltdirection1[0] = 1.;
   Tiltdirection1[1] = 0.;
 }

 LL = fabs(vx1*Rx + vy1*Ry);
 if( LL < 1.e-10) continue;
 Aellipsis1 = r1*aaa/LL;

 if(istampa >= 3 && IVOLTE<= nmassimo){
   cout<<"Lunghezza asse maggiore ellisse1 = "<<Aellipsis1<<";  raggio drift1 = "<<r1<<";  Tdirz = "<<Tiltdirection1[0]
       <<";  TdirFI = "<<Tiltdirection1[1]<<endl;
   cout<<"cos angolo con la normale = "<<LL/aaa<<endl;
 }

// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder
// under the safe assumption that the ellipse has the major axis in Z direction.

 if(
    Aellipsis1 > semilengthStraight1-fabs(POINTS1[i1+2]-Zcenter1)   ||
    Aellipsis1 > semilengthStraight2-fabs(POINTS1[i1+2]-Zcenter2)   ||
    Aellipsis1 > semilengthStraight3-fabs(POINTS1[i1+2]-Zcenter3)   ||
    distance1[k1] + Aellipsis1 > semilengthSkew1        //  the ellipsis goes out of the boundaries of the skew straw
   )  continue;




  fi1 = atan2(POINTS1[i1+1]-Oy, POINTS1[i1]-Ox) ;  // atan2 returns radians in (-pi and +pi]
  if( fi1 < 0.) fi1 += 2.*PI;


 for(k2=0; k2<2;k2++){
  if(  BAD2[k2] )  continue;

  i2 = 3*k2;

//  calculation of the approximate axis length of the ellipses projection of the skew straw on the plane tangent to the trajectory cylinder.
//  first skew straw

  Rx = POINTS2[i2]-Ox ;   //  x direction along R of cylinder of trajectory
  Ry = POINTS2[1+i2]-Oy ;   //  y direction along R of cylinder of trajectory

  aaa = sqrt(Rx*Rx+Ry*Ry);
  SkewInclWithRespectToS = (-Ry*vx2 + Rx*vy2)/aaa ;
  SkewInclWithRespectToS /= R;
  bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz2*vz2);
//  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
 if( bbb > 1.e-10){
   Tiltdirection2[0] = vz2/bbb;
   Tiltdirection2[1] = SkewInclWithRespectToS/bbb;
 } else {
   Tiltdirection2[0] = 1.;
   Tiltdirection2[1] = 0.;
 }
 LL = fabs(vx2*Rx + vy2*Ry);
 if(LL < 1.e-10) continue;
 Aellipsis2 = r2*aaa/LL;
// Bellipsis2 = r2;

// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

  if(
    Aellipsis2 > semilengthStraight1-fabs(POINTS2[i2+2]-Zcenter1)   ||  // the ellipsis goes out of the boundaries of the straight straws
    Aellipsis2 > semilengthStraight2-fabs(POINTS2[i2+2]-Zcenter2)   ||
    Aellipsis2 > semilengthStraight3-fabs(POINTS2[i2+2]-Zcenter3)   ||
    distance2[k2] + Aellipsis2 > semilengthSkew2        //  the ellipsis goes out of the boundaries of the skew straw
    )  continue;


//    end of boundaries checks, now find KAPPA and FI0





     fi2 = atan2(POINTS2[i2+1]-Oy, POINTS2[i2]-Ox) ;  // atan2 returns radians in (-pi and +pi]
     if ( fi2 < 0.)  fi2 += 2.*PI;





//   translation with the new variables ( those of the lateral surface of the trajectory cylinder and with the first ellipsis
//   positioned at 0,0


  for ( enne = -1; enne<2; enne++) {    //  enne  is the order of the solution


//   translation with the new variables ( those of the lateral surface of the trajectory cylinder and with the first ellipsis
//   positioned at 0,0



     Result.Nhelix[enne+1] = 4;

  for(i=0; i<2; i++){
   for(j=0; j<2; j++){

     x1 =  POINTS1[i1+2] + (1 - 2*j)*Aellipsis1*Tiltdirection1[0];
     y1 = fi1 + (1 - 2*j)*Aellipsis1*Tiltdirection1[1] ;
     x2 =  POINTS2[i2+2] + (1 - 2*i)*Aellipsis2*Tiltdirection2[0];
     y2 = fi2 + (1 - 2*i)*Aellipsis2*Tiltdirection2[1] + enne * 2. * PI  ;




     Nsolutions = j + 2*i;

     if ( x2-x1 != 0.){
       Result.KAPPA[enne+1][Nsolutions] =  (y2-y1) / (x2-x1) ;
       Result.FI0[enne+1][Nsolutions] = -Result.KAPPA[enne+1][Nsolutions] * x1 + y1;
     } else {
       Result.KAPPA[enne+1][Nsolutions] = 1.e14;
       Result.FI0[enne+1][Nsolutions] = x1;
     }

    }
   }      //  end of   for(i=0; i<2; i++)







// --------------------- inizio stampe diagnostiche e macros diagnostiche



// --------------------------------------------------------------------   stampa delle macro di controllo
if(iplotta && IVOLTE <= nmassimo){

  Bellipsis1 = r1/R;
  Bellipsis2 = r2/R;

  SSS1=atan2(POINTS1[i1+1]-Oy,POINTS1[i1]-Ox);
  if( SSS1<0.) SSS1 +=2.*PI;
  SSS2=atan2(POINTS2[i2+1]-Oy,POINTS2[i2]-Ox);
  if( SSS2<0.) SSS2 +=2.*PI;
  SSS2 += 2.*PI*enne;

for(i=0,nfile=0; i<4; i++){
 if(ntimes < 3){
  nfile++;

  aaa = fabs(POINTS1[i1+2]-POINTS2[i2+2])*0.05;
  bbb = fabs(SSS1-SSS2)*0.05;

  if(POINTS1[i1+2]-Aellipsis1<POINTS2[i2+2]-Aellipsis2){xmin=POINTS1[i1+2]-Aellipsis1-aaa;} else
{xmin=POINTS2[i2+2]-Aellipsis2-aaa;}
  if(POINTS1[i1+2]+Aellipsis1>POINTS2[i2+2]+Aellipsis2){xmax=POINTS1[i1+2]+Aellipsis1+aaa;} else
{xmax=POINTS2[i2+2]+Aellipsis2+aaa;}

  if( SSS1-Bellipsis1 < SSS2-Bellipsis2){ ymin = SSS1-Bellipsis1-bbb; } else { ymin = SSS2-Bellipsis2-bbb; }
  if( SSS1+Bellipsis1 > SSS2+Bellipsis2){ ymax = SSS1+Bellipsis1+bbb; } else { ymax = SSS2+Bellipsis2+bbb;}

  if( enne < 0) {
   sprintf(nome,"macro1_combination%d_ennemeno%d_kuno%d_kdue%dn%d.C",ntimes,-enne,k1,k2,nfile);
  } else {
   sprintf(nome,"macro1_combination%d_enne%d_kuno%d_kdue%dn%d.C",ntimes,enne,k1,k2,nfile);
  }
  FILE * MACRO = fopen(nome,"w");
  if( enne < 0) {
    fprintf(MACRO,"void macro1_combination%d_ennemeno%d_kuno%d_kdue%dn%d()\n{\n",ntimes,-enne,k1,k2,nfile);
  } else {
    fprintf(MACRO,"void macro1_combination%d_enne%d_kuno%d_kdue%dn%d()\n{\n",ntimes,enne,k1,k2,nfile);
  }

  Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
  Double_t rotation2 = 180.*atan2(Tiltdirection2[1],Tiltdirection2[0])/PI;
  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);
  fprintf(MACRO,"TEllipse* E1 = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\n",POINTS1[i1+2],SSS1,Aellipsis1,Bellipsis1,rotation1);
  fprintf(MACRO,"TEllipse * E2 = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\n",POINTS2[i2+2],SSS2,Aellipsis2,Bellipsis2,rotation2);
  fprintf(MACRO,"TLine* L = new TLine(%f,%f,%f,%f);\n",
        xmin,
        Result.KAPPA[enne+1][i]*xmin+Result.FI0[enne+1][i],
        xmax,
        Result.KAPPA[enne+1][i]*xmax+Result.FI0[enne+1][i]
         );
  fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin+(xmax-xmin)*0.1,
                           ymin+(ymax-ymin)*0.1,xmin+(xmax-xmin)*0.1,ymax-(ymax-ymin)*0.1,
                          ymin+(ymax-ymin)*0.1,ymax-(ymax-ymin)*0.1);
  fprintf(MACRO,"Assey->Draw();\n");
  fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin+(xmax-xmin)*0.1,
                           ymin+(ymax-ymin)*0.1,xmax-(xmax-xmin)*0.1,ymin+(ymax-ymin)*0.1,
                          xmin+(xmax-xmin)*0.1,xmax-(xmax-xmin)*0.1);
  fprintf(MACRO,"Assex->Draw();\n");
  if( ymin<2.*PI && ymax > 2.*PI) {
    fprintf(MACRO,"TLine* TWOPI = new TLine(%f,%f,%f,%f);\nTWOPI->SetLineColor(2);\nTWOPI->Draw();\n",
                 xmin,2.*PI,xmax,2.*PI);
  }
  if( ymin<0. && ymax > 0.) {
    fprintf(MACRO,"TLine* BASE = new TLine(%f,%f,%f,%f);\nBASE->SetLineColor(2);\nBASE->Draw();\n",
                 xmin,0.,xmax,0.);
  }
  if( ymin<-2.*PI && ymax > -2.*PI) {
    fprintf(MACRO,"TLine* NEG = new TLine(%f,%f,%f,%f);\nNEG->SetLineColor(2);\nNEG->Draw();\n",
                 xmin,-2.*PI,xmax,-2.*PI);
  }
  fprintf(MACRO,"TLine* Teorica = new TLine(%f,%f,%f,%f);\n",
        xmin,
        xmin/R + 3.*PI/2.,
        xmax,
        xmax/R + 3.*PI/2.
         );
  fprintf(MACRO,"Teorica->SetLineColor(4);\n");
  fprintf(MACRO,"E1->Draw();\nE2->Draw();\nL->Draw();\nTeorica->Draw();\n}\n");
  fclose(MACRO);
 }  //    end of   if(ntimes < 3)

}   //    end   of   for(i=0; i<jtemp; i++)

// -----------------------------------------------------------------  fine  stampa delle macro di controllo

     }   //  end if(iplotta)
// --------------------- fine stampe diagnostiche e macros diagnostiche




   }  //   end  for(enne=0; enne<2; enne++)

  }   // end  for(k2=0;
 }   // end  for(k1=0;

  NTOTAL=4;
 *STATUS = NTOTAL;
 
//----------------------------------------------------------------------------------------------------------------------

/*
cout<<"ultima stampa, N totale soluzioni = "<<NTOTAL<<"; N a 0 giri = "<<
     Result.Nhelix[1]<<"; N a 1 giro "<<Result.Nhelix[2]<<"; N ad un giro sotto "<<Result.Nhelix[0]<<endl;

cout<<"Esce da PndSttTrkFindHelix.........\n";
*/



 return Result;

}
//--------------------------------  end of function         PndSttTrackFinderReal::PndSttTrkFindHelix






//--------------------------------  begin of function         PndSttTrackFinderReal::calculateintersections

 void PndSttTrackFinderReal::calculateintersections(Double_t Ox,Double_t Oy,Double_t R,Double_t C0x,Double_t C0y,
                   Double_t C0z,Double_t r,Double_t vx,Double_t vy,Double_t vz,
                   Int_t *STATUS, Double_t* POINTS)
{


//-------------------------------------------


  Double_t P1x, P1y, P1z, P2x, P2y, P2z;

  Double_t AAA, DELTA, ax, ay, aaa;




/*
 INPUTS :

  Ox, Oy        = abscissa and ordinate of the center of the circular trajectory of
                  the particle;
  R             = radius of such trajectory;
  C0x, C0y, Coz = x, y, z coordinates of a point belonging to the axis of the
                  skewed straw;
  r  = radius of equidrift of such skewed straw;
  vx, vy, vz    =  versor of the direction along which the skewed straw lies.


 OUTPUTS :

  P1x, P1y, P1z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (first
                    solution);
  P2x, P2y, P2z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (second
                    solution);

 P1x, P1y, .... , P2z  are stored in the array POINTS[0-5];  the status is stored
 in *STATUS.

*/




//--------------------------------------------------------------------------


// from the resolving formula on page 23 of Gianluigi's notes, setting  r=0.


  ax = C0x - Ox;
  ay = C0y - Oy;
  DELTA = R*R*(vx*vx+vy*vy) - (vx*ay - vy*ax)*(vx*ay - vy*ax);
  AAA = vx*vx+vy*vy;


  if ( DELTA < 0. ) {
      *STATUS=-2;
  } else if (AAA == 0.){
      *STATUS=-3;
  } else if (DELTA == 0.){
      *STATUS=1;
      POINTS[0] = C0x - vx*(vx*ax + vy*ay)/AAA;
      POINTS[1] = C0y - vy*(vx*ax + vy*ay)/AAA;
      POINTS[2] = C0z - vz*(vx*ax + vy*ay)/AAA;
  }else {
      *STATUS=0;
      DELTA = sqrt(DELTA);
      POINTS[0] = C0x - vx*(vx*ax + vy*ay - DELTA)/AAA;
      POINTS[1] = C0y - vy*(vx*ax + vy*ay - DELTA)/AAA;
      POINTS[2] = C0z - vz*(vx*ax + vy*ay - DELTA)/AAA;
      POINTS[3] = C0x - vx*(vx*ax + vy*ay + DELTA)/AAA;
      POINTS[4] = C0y - vy*(vx*ax + vy*ay + DELTA)/AAA;
      POINTS[5] = C0z - vz*(vx*ax + vy*ay + DELTA)/AAA;
  }

   return;


}



//----------end of function PndSttTrackFinderReal::calculateintersections













//----------begin function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix

  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix(
                   Double_t Ox,
                   Double_t Oy,
                   Double_t R,
                   Int_t Nhits,
                   Double_t info[][7],
                   UShort_t *auxListHitsinTrack              //  this is the output
                                                     )
{

    Int_t i;
    UShort_t Nassociatedhits;

    Double_t dx, dy,distance;


//    Ox = (D+R)*cos(Fi);
//    Oy = (D+R)*sin(Fi);



//  association of hits in the XY plane

       Nassociatedhits=0;

       for( i=0; i< Nhits; i++) {


//          Kincl = (int) info[i][5] - 1;

// --------------------    association of the hits from parallel straws
//         if( info[i][5] == 1. ) {     // parallel straws

          dx = -Ox+info[ infoparal[i] ][0];
          dy = -Oy+info[ infoparal[i] ][1];
          distance = sqrt(dx*dx+dy*dy);
//cout<<"nuov, R "<<R<<",  distance  "<<distance<<endl;
//          if( distance < 1.e-10)  continue;
//          angle = atan2(dy,dx);

          if ( fabs(R - distance ) > 2.*StrawRadius )  continue;
          auxListHitsinTrack[Nassociatedhits]=i;
          Nassociatedhits++;

//         }    //  end of   if( info[i][5] == 1 )  else


       }    //   end of   for( i=1; i< Nhits; i++)






    return Nassociatedhits;

}


//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix





//----------start of function PndSttTrackFinderReal::plottamentiParalleleGenerali

 void  PndSttTrackFinderReal::plottamentiParalleleGenerali(
                      Int_t Nremaining, Float_t * RemainingR, Float_t * RemainingD,
                      Float_t * RemainingFi, Float_t * RemainingCX, Float_t * RemainingCY,
                      bool *Goodflag  
                       )
{


   int itemp, i, j, ii, jj;

   Double_t  D, Fi;

   char nome[300],titolo[300];



   sprintf(nome,"HoughGeneralPlotsEvent%d.root",IVOLTE);
   TFile  hfile(nome,"RECREATE", "STT pattern recognition");

//----------
       sprintf(titolo,"Cxofcircle");
       TH1F hCX(titolo,titolo,nbinCX,CXmin,CXmax);
//----------
       sprintf(titolo,"Cyofcircle");
       TH1F hCY(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"Radiusofcircle");
       TH1F hR(titolo,titolo,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCy");
       TH2F hCX_CY(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"CxabscissavsRadius");
       TH2F hCX_R(titolo,titolo,nbinCX,CXmin,CXmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CyabscissavsRadius");
       TH2F hCY_R(titolo,titolo,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadius");
       TH3F hCX_CY_R(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"Distanceofclosestapproachofcircle");
       TH1F hD(titolo,titolo,nbinD,Dmin,Dmax);
//----------
       sprintf(titolo,"Firadofcircle");
       TH1F hFi(titolo,titolo,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsFi");
       TH2F hD_Fi(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsRadius");
       TH2F hD_R(titolo,titolo,nbinD,Dmin,Dmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"FiabscissavsRadius");
       TH2F hFi_R(titolo,titolo,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadius");
       TH3F hD_Fi_R(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----

//---------------------------------------------------
//   gli stessi plots ma per le soluzioni che sono le piu' vicine alla verita' MC
//----------
       sprintf(titolo,"Cxofcircle_truth");
       TH1F hCXverita(titolo,titolo,nbinCX,CXmin,CXmax);
//----------
       sprintf(titolo,"Cyofcircle_truth");
       TH1F hCYverita(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"Radiusofcircle_truth");
       TH1F hRverita(titolo,titolo,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCy_truth");
       TH2F hCX_CYverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"CxabscissavsRadius_truth");
       TH2F hCX_Rverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CyabscissavsRadius_truth");
       TH2F hCY_Rverita(titolo,titolo,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadius_truth");
       TH3F hCX_CY_Rverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"Distanceofclosestapproachofcircle_truth");
       TH1F hDverita(titolo,titolo,nbinD,Dmin,Dmax);
//----------
       sprintf(titolo,"Firadofcircle_truth");
       TH1F hFiverita(titolo,titolo,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsFi_truth");
       TH2F hD_Fiverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsRadius_truth");
       TH2F hD_Rverita(titolo,titolo,nbinD,Dmin,Dmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"FiabscissavsRadius_truth");
       TH2F hFi_Rverita(titolo,titolo,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadius_truth");
       TH3F hD_Fi_Rverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----

//---------------------------------------------------
//   gli stessi plots ma per le soluzioni che NON sono le piu' vicine alla verita' MC
//----------
       sprintf(titolo,"Cxofcircle_nontruth");
       TH1F hCXnonverita(titolo,titolo,nbinCX,CXmin,CXmax);
//----------
       sprintf(titolo,"Cyofcircle_nontruth");
       TH1F hCYnonverita(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"Radiusofcircle_nontruth");
       TH1F hRnonverita(titolo,titolo,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCy_nontruth");
       TH2F hCX_CYnonverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"CxabscissavsRadius_nontruth");
       TH2F hCX_Rnonverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CyabscissavsRadius_nontruth");
       TH2F hCY_Rnonverita(titolo,titolo,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadius_nontruth");
       TH3F hCX_CY_Rnonverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"Distanceofclosestapproachofcircle_nontruth");
       TH1F hDnonverita(titolo,titolo,nbinD,Dmin,Dmax);
//----------
       sprintf(titolo,"Firadofcircle_nontruth");
       TH1F hFinonverita(titolo,titolo,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsFi_nontruth");
       TH2F hD_Finonverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsRadius_nontruth");
       TH2F hD_Rnonverita(titolo,titolo,nbinD,Dmin,Dmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"FiabscissavsRadius_nontruth");
       TH2F hFi_Rnonverita(titolo,titolo,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadius_nontruth");
       TH3F hD_Fi_Rnonverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----

//---------------------------------------------------





  for(itemp = 0; itemp<Nremaining; itemp++){

       D = RemainingD[itemp];
       Fi = RemainingFi[itemp];


       hCX.Fill(RemainingCX[itemp]);
       hCY.Fill(RemainingCY[itemp]);
       hR.Fill(RemainingR[itemp]);
       hCX_CY.Fill(RemainingCX[itemp],RemainingCY[itemp]);
       hCX_R.Fill(RemainingCX[itemp],RemainingR[itemp]);
       hCY_R.Fill(RemainingCY[itemp],RemainingR[itemp]);
       hCX_CY_R.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);

       hD.Fill(D);
       hFi.Fill(Fi);
       hD_Fi.Fill(D,Fi);
       hD_R.Fill(D,RemainingR[itemp]);
       hFi_R.Fill(Fi,RemainingR[itemp]);
       hD_Fi_R.Fill(D,Fi,RemainingR[itemp]);



        

     if (Goodflag[itemp]) {

       hCXverita.Fill(RemainingCX[itemp]);
       hCYverita.Fill(RemainingCY[itemp]);
       hRverita.Fill(RemainingR[itemp]);
       hCX_CYverita.Fill(RemainingCX[itemp],RemainingCY[itemp]);
       hCX_Rverita.Fill(RemainingCX[itemp],RemainingR[itemp]);
       hCY_Rverita.Fill(RemainingCY[itemp],RemainingR[itemp]);
       hCX_CY_Rverita.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);

       hDverita.Fill(D);
       hFiverita.Fill(Fi);
       hD_Fiverita.Fill(D,Fi);
       hD_Rverita.Fill(D,RemainingR[itemp]);
       hFi_Rverita.Fill(Fi,RemainingR[itemp]);
       hD_Fi_Rverita.Fill(D,Fi,RemainingR[itemp]);

     }   else {

       hCXnonverita.Fill(RemainingCX[itemp]);
       hCYnonverita.Fill(RemainingCY[itemp]);
       hRnonverita.Fill(RemainingR[itemp]);
       hCX_CYnonverita.Fill(RemainingCX[itemp],RemainingCY[itemp]);
       hCX_Rnonverita.Fill(RemainingCX[itemp],RemainingR[itemp]);
       hCY_Rnonverita.Fill(RemainingCY[itemp],RemainingR[itemp]);
       hCX_CY_Rnonverita.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);

       hDnonverita.Fill(D);
       hFinonverita.Fill(Fi);
       hD_Finonverita.Fill(D,Fi);
       hD_Rnonverita.Fill(D,RemainingR[itemp]);
       hFi_Rnonverita.Fill(Fi,RemainingR[itemp]);
       hD_Fi_Rnonverita.Fill(D,Fi,RemainingR[itemp]);

     }





   }  //  end of    for(Int_t itemp = 0; itemp<Nremaining; itemp++)





   hfile.Write(nome);
   hfile.Close();

 }

//----------end of function PndSttTrackFinderReal::plottamentiParalleleGenerali


//----------start of function PndSttTrackFinderReal::plottamentiParalleleconMassimo

 void  PndSttTrackFinderReal::plottamentiParalleleconMassimo(
                       char * tipo,
                      Int_t nMaxima,
                      Int_t Nremaining, Float_t * RemainingR, Float_t * RemainingD,
                      Float_t * RemainingFi, Float_t * RemainingCX, Float_t * RemainingCY,  
                Double_t Rup, Double_t Rlow, Double_t Dup, Double_t Dlow, Double_t Fiup, Double_t Filow
                                                            )
 {


   int itemp, i, j, ii, jj;

   Double_t  D, Fi;

   char nome[300],titolo[300];



   sprintf(nome,"HoughParallele%sMaximumN%devent%d.root",tipo,nMaxima,IVOLTE);
   TFile  hfile(nome,"RECREATE", "STT pattern recognition");


//----------
       sprintf(titolo,"CxofcircleSelected");
       TH1F hCXsel(titolo,titolo,nbinCX,CXmin,CXmax);
//-----
       sprintf(titolo,"CyofcircleSelected");
       TH1F hCYsel(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"RadiusofcircleSelected");
       TH1F hRsel(titolo,titolo,nbinR,Rlow,Rup);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadiusSelected");
       TH3F hCX_CY_Rsel(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rlow,Rup);
//----------
       sprintf(titolo,"DistanceofclosestapproachofcircleSelected");
       TH1F hDsel(titolo,titolo,nbinD,Dlow,Dup);
//-----
       sprintf(titolo,"FiradofcircleSselected");
       TH1F hFisel(titolo,titolo,nbinFi,Filow,Fiup);
//-----
       sprintf(titolo,"DabscissavsFiSelected");
       TH2F hD_Fisel(titolo,titolo,nbinD,Dlow,Dup,nbinFi,Filow,Fiup);
//-----
       sprintf(titolo,"DabscissavsRadiusSelected");
       TH2F hD_Rsel(titolo,titolo,nbinD,Dlow,Dup,nbinR,Rlow,Rup);
//-----
       sprintf(titolo,"FiabscissavsRadiusSelected");
       TH2F hFi_Rsel(titolo,titolo,nbinFi,Filow,Fiup,nbinR,Rlow,Rup);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadiusSelected");
       TH3F hD_Fi_Rsel(titolo,titolo,nbinD,Dlow,Dup,nbinFi,Filow,Fiup,nbinR,Rlow,Rup);




  for(itemp = 0; itemp<Nremaining; itemp++){

       D = RemainingD[itemp];
       Fi = RemainingFi[itemp];


      if( RemainingR[itemp]>Rlow && RemainingR[itemp]<Rup
                             &&
          RemainingD[itemp]>Dlow && RemainingD[itemp]<Dup
                             &&
          RemainingFi[itemp]>Filow && RemainingFi[itemp]<Fiup
        )  {
           hRsel.Fill(RemainingR[itemp]);
           hFisel.Fill(Fi);
           hDsel.Fill(D);
           hCXsel.Fill(RemainingCX[itemp]);
           hCYsel.Fill(RemainingCY[itemp]);
           hD_Fisel.Fill(D,Fi);
           hD_Rsel.Fill(D,RemainingR[itemp]);
           hFi_Rsel.Fill(Fi,RemainingR[itemp]);
           hD_Fi_Rsel.Fill(D,Fi,RemainingR[itemp]);
           hCX_CY_Rsel.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);
      }

   }  //  end of    for(Int_t itemp = 0; itemp<Nremaining; itemp++)






   hfile.Write(nome);
   hfile.Close();

 }

//----------end of function PndSttTrackFinderReal::plottamentiParalleleconMassimo







  bool  PndSttTrackFinderReal::iscontiguous(
                int ncomponents, UShort_t * vec1, UShort_t *vec2)
{

    for(int i=0; i<ncomponents;i++){
      if( vec1[i]-vec2[i] >3 || vec1[i]-vec2[i]<-3) return false;
    }

    return true;

}



//----------end of function PndSttTrackFinderReal::iscontiguous

void PndSttTrackFinderReal::clustering2(
          UShort_t vec1[2],                                       // input
          int nListElements, UShort_t List[][2],                 // input
          int & nClusterElementsFound, UShort_t ClusterElementsFound[][2],  // output
          int & nRemainingElements, UShort_t  RemainingElements[][2]     // output
                )
{
   int i;
   UShort_t  vec2[2];

   nClusterElementsFound=0;
   nRemainingElements=0;
   for(i=0; i<nListElements; i++){
      vec2[0]=List[i][0];
      vec2[1]=List[i][1];
      if( iscontiguous(2, vec1, vec2) ){
         ClusterElementsFound[nClusterElementsFound][0] = vec2[0];
         ClusterElementsFound[nClusterElementsFound][1] = vec2[1];
         nClusterElementsFound++;
      } else {
         RemainingElements[nRemainingElements][0] = vec2[0];
         RemainingElements[nRemainingElements][1] = vec2[1];
         nRemainingElements++;
      }
   }

    return;
}



//----------end of function PndSttTrackFinderReal::clustering2

void PndSttTrackFinderReal::clustering3 (
          UShort_t vec1[3],                                       // input
          int nListElements, UShort_t List[][3],                 // input
          int & nClusterElementsFound, UShort_t ClusterElementsFound[][3],  // output
          int & nRemainingElements, UShort_t  RemainingElements[][3]     // output
                )
{
   int i;
   UShort_t  vec2[3];

   nClusterElementsFound=0;
   nRemainingElements=0;
   for(i=0; i<nListElements; i++){
      vec2[0]=List[i][0];
      vec2[1]=List[i][1];
      vec2[2]=List[i][2];
      if( iscontiguous(3, vec1, vec2) ){
         ClusterElementsFound[nClusterElementsFound][0] = vec2[0];
         ClusterElementsFound[nClusterElementsFound][1] = vec2[1];
         ClusterElementsFound[nClusterElementsFound][2] = vec2[2];
         nClusterElementsFound++;
      } else {
         RemainingElements[nRemainingElements][0] = vec2[0];
         RemainingElements[nRemainingElements][1] = vec2[1];
         RemainingElements[nRemainingElements][2] = vec2[2];
         nRemainingElements++;
      }
   }

    return;
}



//----------end of function PndSttTrackFinderReal::clustering3






//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneral

  void PndSttTrackFinderReal::WriteMacroParallelHitsGeneral(
		bool * keepit,
                   Int_t Nhits, Double_t info[][7],
		   Int_t Nincl, Int_t Minclinations[],
		   Double_t inclination[][3],
                   UShort_t nTracksFoundSoFar,
                   bool *TypeConf,
                   Double_t *ALFA, Double_t *BETA, Double_t *GAMMA
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu,
           Ox[nmaxHits], Oy[nmaxHits], Radius[nmaxHits], gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, rrr, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];

      char nome[300], nome2[300];





//---------- parallel straws Macro now
      sprintf(nome,"MacroGeneralParallelHitsEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
          }
       }




//-------------------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){
	if(!keepit[i]) continue;
     if( TypeConf[i] ){
       aaa = -0.5*ALFA[i];
       bbb = -0.5*BETA[i];
//  Questa riga perche' so che la crf passa per origine
       rrr = sqrt( aaa*aaa+bbb*bbb);
//       rrr = sqrt( aaa*aaa+bbb*bbb-GAMMA[i]);
          fprintf(MACRO,
"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);

     } else {
       if(fabs(BETA[i]) < 1.e-10){
//         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,- GAMMA[i]/ALFA[i],ymin,- GAMMA[i]/ALFA[i],ymax);
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,0.,ymin,0.,ymax);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       } else {
 //        yl = -xmin*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
//         yu = -xmax*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
         yl = -xmin*ALFA[i]/BETA[i];
         yu = -xmax*ALFA[i]/BETA[i];
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       }
     }




if(istampa>= 3 && IVOLTE <= nmassimo) {
  cout<<"stampa da WriteMacroParallelHitsGeneral , for trackfoundsofar n. "<<i<<",  typconf "<<
   TypeConf[i]<<",  nel normale piano XY;  alfa "<<ALFA[i]<<",  beta "<<BETA[i]<<", gamma "<<GAMMA[i]
       <<"  a cui corrisponde  Cx = "<<-0.5*ALFA[i]<<",  Cy = "<<-0.5*BETA[i]<<" ed  R = "
//       << sqrt( aaa*aaa+bbb*bbb-GAMMA[i]) <<endl;
       << sqrt( aaa*aaa+bbb*bbb) <<endl;
}




    }

// -----------



      fprintf(MACRO,"}\n");
      fclose(MACRO);
       
//------------------------------------------------------------------------------------------------------------


//---------- parallel straws Macro now con anche le tracce MC



	if(!doMcComparison) goto dopo ;


      sprintf(nome,"MacroGeneralParallelHitswithMCEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
          }
       }

//---------------------------  ora le tracce MC
	Int_t icode;
         Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica  ;
     PndMCTrack* pMC;
	for(int im=0;im<nMCTracks; im++){
		pMC = (PndMCTrack*) fMCTrackArray->At(im);
		if ( ! pMC ) continue;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       if (icode>1000000000) carica = 1.;
       else  carica = fParticle->Charge()/3. ;    //   charge of track
	if( fabs(carica)<0.1) continue;
           Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
            fprintf(MACRO,"TEllipse* MC%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMC%d->SetFillStyle(0);\nMC%d->SetLineColor(3);\nMC%d->Draw();\n",
                     im,Cx,Cy,Rr,Rr,im,im,im);
       }  //  end of for(int im=0;im<nMCTracks; im++)

//----------- fine parte del MC

//-------------------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){
	if(!keepit[i]) continue;

     if( TypeConf[i] ){
       aaa = -0.5*ALFA[i];
       bbb = -0.5*BETA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb-GAMMA[i]);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
     } else {
       if(fabs(BETA[i]) < 1.e-10){
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,- GAMMA[i]/ALFA[i],ymin,- GAMMA[i]/ALFA[i],ymax);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       } else {
         yl = -xmin*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
         yu = -xmax*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       }
     }


    }

// -----------

      fprintf(MACRO,"}\n");
      fclose(MACRO);
       

dopo:  ;
//------------------------------------------------------------------------------------------------------------







//   ora riplotto tutto nello spazio conforme usando la trasformazione u= x/(x**2+y**2) e   v = y/(x**2+y**2)
//
//   aggiungo anche la grigliatura dello spazio conforme usata per la box del pattern recognition

      sprintf(nome,"MacroGeneralParallelHitsConformeEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
//   centro sfera in sistema conforme
            gamma = info[i][0]*info[i][0] + info[i][1]*info[i][1] - info[i][3]*info[i][3];
            Ox[i] = info[i][0] / gamma;
            Oy[i] = info[i][1] / gamma;
            Radius[i] = info[i][3]/gamma;
            if (Ox[i]-Radius[i] < xmin)   xmin = Ox[i]-Radius[i];
            if (Ox[i]+Radius[i] > xmax)   xmax = Ox[i]+Radius[i];
            if (Oy[i]-Radius[i] < ymin)   ymin = Oy[i]-Radius[i];
            if (Oy[i]+Radius[i] > ymax)   ymax = Oy[i]+Radius[i];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

// ora la grigliatura  con i cerchi

       fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     nRdivConformalEffective,1./RStrawDetectorMin,1./RStrawDetectorMin,nRdivConformalEffective,nRdivConformalEffective);

       for( i=nRdivConformalEffective-1; i>=0 ; i--) {
            fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     i,radiaConf[i],radiaConf[i],i,i);
       }
//---------------------
// ora la grigliatura  con i segmenti

       for(i=0;  i<nFidivConformal; i++) {
            ff = i*2.*PI/nFidivConformal;
            x1=cos(ff)/RStrawDetectorMax;
            y1=sin(ff)/RStrawDetectorMax;
            x2=cos(ff)/RStrawDetectorMin;
            y2=sin(ff)/RStrawDetectorMin;
            fprintf(MACRO,"TLine* Seg%d = new TLine(%f,%f,%f,%f);\nSeg%d->SetLineColor(4);\nSeg%d->Draw();\n",
                     i,x1,y1,x2,y2,i,i);
       }
//---------------------

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,Ox[i],Oy[i],Radius[i],Radius[i],i,i);
          }
       }




//------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){
	if(!keepit[i]) continue;


// cout<<" da writeparallelhitsgeneral, traccia found n. "<<i<<", typeconf "<<TypeConf[i]
//  <<",  alfa "<<ALFA[i]<<",  beta  "<<BETA[i]<<",  gamma "<<GAMMA[i]<<endl;

//  assumo che tutte le traiettorie siano rette nello spazio conforme, perche' le tracce vengono dal vertice primario

     if( TypeConf[i] ){

//      if( fabs(GAMMA[i]) > 1.e-10) {
//       aaa = -0.5*ALFA[i]/GAMMA[i];
//       bbb = -0.5*BETA[i]/GAMMA[i];
//       rrr = sqrt( 0.25*ALFA[i]*ALFA[i]+0.25*BETA[i]*BETA[i]-GAMMA[i])/fabs(GAMMA[i]);
//       if( fabs(rrr/GAMMA[i]) < 30.) {
//         fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
//                     i,aaa,bbb,rrr,rrr,i,i,i);
//       }  else {
//          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
//          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
//          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
//          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
//          fprintf(MACRO,"ris%d->Draw();\n",i);
//       }
//      }  else {

        if(fabs(BETA[i]) < 1.e-10){
         if(fabs(ALFA[i])<1.e-10) {
          continue;
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,-1./ALFA[i],ymin,- 1./ALFA[i],ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
        } else {
          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
        }

//      }

     } else {   // in this case TypConf = 0 -->  straight line in XY


      if( fabs(GAMMA[i]) > 1.e-10) {
       aaa = -0.5*ALFA[i]/GAMMA[i];
       bbb = -0.5*BETA[i]/GAMMA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
      }  else {
         if(fabs(BETA[i])>1.e-10) {
          yl = -xmin*ALFA[i]/BETA[i] ;
          yu = -xmax*ALFA[i]/BETA[i] ;
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,0.,ymin,0.,ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
      }

     }
    }

// ------------------------------

     fprintf(MACRO,"}\n");
     fclose(MACRO);
       







    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneral



















//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMC

  void PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMC(
		bool * keepit,
                   Int_t Nhits, Double_t info[][7], Int_t Nincl,
		    Int_t Minclinations[], Double_t inclination[][3],
                   UShort_t nTracksFoundSoFar,
                   bool *TypeConf,
                   Double_t *ALFA, Double_t *BETA, Double_t *GAMMA
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu, rrr,
           Ox[nmaxHits], Oy[nmaxHits], Radius[nmaxHits], gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           zl[200],zu[200];






//---------- parallel straws Macro now
      char nome[300], nome2[300];
      FILE * MACRO;

       
//   ora riplotto tutto nello spazio conforme usando la trasformazione u= x/(x**2+y**2) e   v = y/(x**2+y**2)
//
//   aggiungo anche la grigliatura dello spazio conforme usata per la box del pattern recognition

      sprintf(nome,"MacroGeneralParallelHitsConformewithMCEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
//   centro sfera in sistema conforme
            gamma = info[i][0]*info[i][0] + info[i][1]*info[i][1] - info[i][3]*info[i][3];
            Ox[i] = info[i][0] / gamma;
            Oy[i] = info[i][1] / gamma;
            Radius[i] = info[i][3]/gamma;
            if (Ox[i]-Radius[i] < xmin)   xmin = Ox[i]-Radius[i];
            if (Ox[i]+Radius[i] > xmax)   xmax = Ox[i]+Radius[i];
            if (Oy[i]-Radius[i] < ymin)   ymin = Oy[i]-Radius[i];
            if (Oy[i]+Radius[i] > ymax)   ymax = Oy[i]+Radius[i];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

// ora la grigliatura  con i cerchi

       fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     nRdivConformalEffective,1./RStrawDetectorMin,1./RStrawDetectorMin,nRdivConformalEffective,nRdivConformalEffective);

       for( i=nRdivConformalEffective-1; i>=0 ; i--) {
            fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     i,radiaConf[i],radiaConf[i],i,i);
       }
//---------------------
// ora la grigliatura  con i segmenti

       for(i=0;  i<nFidivConformal; i++) {
            ff = i*2.*PI/nFidivConformal;
            x1=cos(ff)/RStrawDetectorMax;
            y1=sin(ff)/RStrawDetectorMax;
            x2=cos(ff)/RStrawDetectorMin;
            y2=sin(ff)/RStrawDetectorMin;
            fprintf(MACRO,"TLine* Seg%d = new TLine(%f,%f,%f,%f);\nSeg%d->SetLineColor(4);\nSeg%d->Draw();\n",
                     i,x1,y1,x2,y2,i,i);
       }
//---------------------

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetLineWidth(2);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,Ox[i],Oy[i],Radius[i],Radius[i],i,i,i);
          }
       }




//------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){
	if(!keepit[i]) continue;

     if( TypeConf[i] ){

      if( fabs(GAMMA[i]) > 1.e-10) {
       aaa = -0.5*ALFA[i]/GAMMA[i];
       bbb = -0.5*BETA[i]/GAMMA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb-1./GAMMA[i]);
       if( fabs(rrr/GAMMA[i]) < 30.) {
           fprintf(MACRO,
"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
       }  else{


          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);



       }
      }  else {

        if(fabs(BETA[i]) < 1.e-10){
         if(fabs(ALFA[i])<1.e-10) {
          continue;
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,-1./ALFA[i],ymin,- 1./ALFA[i],ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
        } else {
          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
        }

      }

     } else {   // in this case TypConf = 0 -->  straight line in XY


      if( fabs(GAMMA[i]) > 1.e-10) {
       aaa = -0.5*ALFA[i]/GAMMA[i];
       bbb = -0.5*BETA[i]/GAMMA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
      }  else {
         if(fabs(BETA[i])>1.e-10) {
          yl = -xmin*ALFA[i]/BETA[i] ;
          yu = -xmax*ALFA[i]/BETA[i] ;
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,0.,ymin,0.,ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
      }

     }
    }

// ------------------------------

//   plotting all the tracks MC generated



	Int_t icode;
         Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica  ;
     PndMCTrack* pMC;
	for(i=0;i<nMCTracks; i++){
		pMC = (PndMCTrack*) fMCTrackArray->At(i);
		if ( ! pMC ) continue;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       if (icode>1000000000) carica = 1.;
       else  carica = fParticle->Charge()/3. ;    //   charge of track
       if (fabs(carica)<0.1 ) continue;
           Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
    gamma = -Rr*Rr + Cx*Cx+Cy*Cy;
    if(fabs(gamma)< 0.001) {
     if(Cy != 0.) {
       yl = xmin*(-Cx/Cy) + 0.5/Cy;
       yu = xmax*(-Cx/Cy) + 0.5/Cy;
       xl = xmin;
       xu = xmax;
     } else {
       yl = ymin;
       yu = ymax;
       xu=xl = 0.5/Cx;
     }
       fprintf(MACRO,"TLine* MCris%d = new TLine(%f,%f,%f,%f);\n",i,xl,yl,xu,yu);
       fprintf(MACRO,"MCris%d->SetLineStyle(2);\n",i);
       fprintf(MACRO,"MCris%d->SetLineColor(3);\n",i);
       fprintf(MACRO,"MCris%d->SetLineWidth(1);\n",i);
       fprintf(MACRO,"MCris%d->Draw();\n",i);

    }  else {
       if(fabs(Rr/gamma) > 1.) {
         if(fabs(Cy)>0.001 ) {
           yl = -xmin*Cx/Cy+0.5/Cy;
           yu = -xmax*Cx/Cy+0.5/Cy;
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
           fprintf(MACRO,"MCline%d->SetLineColor(3);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         } else {
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,2.*CxMC[i],ymin,2.*CxMC[i],ymax);
           fprintf(MACRO,"MCline%d->SetLineColor(2);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         }
        }  else {
           fprintf(MACRO, "TEllipse* MCcerchio%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMCcerchio%d->SetLineColor(3);\n",
                     i,Cx/gamma,Cy/gamma,Rr/fabs(gamma),Rr/fabs(gamma),i);

           fprintf(MACRO,"MCcerchio%d->SetFillStyle(0);\nMCcerchio%d->SetLineStyle(2);\nMCcerchio%d->SetLineWidth(1);\nMCcerchio%d->Draw();\n",
                     i,i,i,i);
        }
    }
   }	// end of for(i=0;i<nMCTracks; i++)



     fprintf(MACRO,"}\n");
     fclose(MACRO);
       







    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMC















//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMCspecial

  void PndSttTrackFinderReal::WriteMacroParallelHitsConformalwithMCspecial(
                   Int_t Nhits,
//                   UShort_t iExclude,
                   Double_t auxinfoparalConformal[][5],
                   UShort_t nTracksFoundSoFar,
                   Double_t * ALFA, 
                   Double_t * BETA, 
                   Double_t * GAMMA, 
                   Short_t Status, Double_t *trajectory_vertex
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu, rrr, cx, cy,
           Ox[nmaxHits], Oy[nmaxHits], Radius[nmaxHits], alfa, beta, gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           zl[200],zu[200];






//---------- parallel straws Macro now
      char nome[300], nome2[300];
      FILE * MACRO;

       
//   ora riplotto tutto nello spazio conforme usando la trasformazione u= x/(x**2+y**2) e   v = y/(x**2+y**2)
//

      sprintf(nome,"MacroParallelHitsConformewithMCspecialEvent%dTrack%d", IVOLTE,nTracksFoundSoFar);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
//             if( i== iExclude)  continue;
//   centro sfera in sistema conforme
            Ox[i] = auxinfoparalConformal[i][0] ;
            Oy[i] = auxinfoparalConformal[i][1] ;
            Radius[i] = auxinfoparalConformal[i][2];
            if (Ox[i]-Radius[i] < xmin)   xmin = Ox[i]-Radius[i];
            if (Ox[i]+Radius[i] > xmax)   xmax = Ox[i]+Radius[i];
            if (Oy[i]-Radius[i] < ymin)   ymin = Oy[i]-Radius[i];
            if (Oy[i]+Radius[i] > ymax)   ymax = Oy[i]+Radius[i];
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
//         if( i== iExclude)  continue;
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetLineWidth(2);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,Ox[i],Oy[i],Radius[i],Radius[i],i,i,i);
       }




//------------------   plotting the track found

     i = nTracksFoundSoFar;
     if( Status != 99){

          rrr = sqrt( 0.25*ALFA[nTracksFoundSoFar]*ALFA[nTracksFoundSoFar] + 0.25*BETA[nTracksFoundSoFar]*BETA[nTracksFoundSoFar]
                    -GAMMA[nTracksFoundSoFar]);
          alfa = ALFA[nTracksFoundSoFar]+2.*trajectory_vertex[0];
          beta = BETA[nTracksFoundSoFar]+2.*trajectory_vertex[1];
          cx = -0.5*alfa;
          cy = -0.5*beta;
          gamma = cx*cx+cy*cy-rrr*rrr;

       if(fabs(gamma) > 1.e-8){
          fprintf(MACRO, "TEllipse* FoundTrack%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nFoundTrack%d->SetLineColor(2);\n",
                     i,cx/gamma,cy/gamma,rrr/fabs(gamma),rrr/fabs(gamma),i);
          fprintf(MACRO,"FoundTrack%d->SetFillStyle(0);\nFoundTrack%d->SetLineStyle(2);\nFoundTrack%d->SetLineWidth(1);\nFoundTrack%d->Draw();\n",
                     i,i,i,i);
       } else {
          if( fabs(beta) > 1.e-8){
            yl = -xmin*alfa/beta-1./beta ;
            yu = -xmax*alfa/beta-1./beta  ;
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          } else {
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,-1./alfa,ymin,-1./alfa,ymax);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          }
       }


     } else {

          alfa = ALFA[nTracksFoundSoFar];
          beta = BETA[nTracksFoundSoFar];
          gamma = GAMMA[nTracksFoundSoFar]+ALFA[nTracksFoundSoFar]*trajectory_vertex[0]+BETA[nTracksFoundSoFar]*trajectory_vertex[1];

          if( fabs(beta) > 1.e-8){
            yl = -xmin*alfa/beta-1./beta ;
            yu = -xmax*alfa/beta-1./beta  ;
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          } else {
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,-1./alfa,ymin,-1./alfa,ymax);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          }


     }



// ------------------------------

//   plotting all the tracks MC generated

//cout<<" TRASLAZIONE IN "<<trajectory_vertex[0]<<",  "<<trajectory_vertex[1]<<endl;


	Int_t icode;
         Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica  ;
     PndMCTrack* pMC;
	for(i=0;i<nMCTracks; i++){
		pMC = (PndMCTrack*) fMCTrackArray->At(i);
		if ( ! pMC ) continue;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       if (icode>1000000000) carica = 1.;
       else  carica = fParticle->Charge()/3. ;    //   charge of track
       if(fabs(carica)<0.1)  continue;
           Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);


//    for(i=0; i<nMCTracks; i++){
     cx = Cx - trajectory_vertex[0];
     cy = Cy - trajectory_vertex[1];
     gamma = -Rr*Rr + (cx*cx+cy*cy);




    if(fabs(gamma)< 0.001) {

     if(cy != 0.) {
       yl = xmin*(-cx/cy) + 0.5/cy;
       yu = xmax*(-cx/cy) + 0.5/cy;
       xl = xmin;
       xu = xmax;
     } else{
       yl = ymin;
       yu = ymax;
       xu=xl = 0.5/cx;
     }
       fprintf(MACRO,"TLine* MCris%d = new TLine(%f,%f,%f,%f);\n",i,xl,yl,xu,yu);
       fprintf(MACRO,"MCris%d->SetLineStyle(2);\n",i);
       fprintf(MACRO,"MCris%d->SetLineColor(3);\n",i);
       fprintf(MACRO,"MCris%d->SetLineWidth(1);\n",i);
       fprintf(MACRO,"MCris%d->Draw();\n",i);

    }  else {


       if(fabs(Rr/gamma) > 1.) {
         if(fabs(Cy)>0.001 ) {
           yl = -xmin*Cx/Cy+0.5/Cy;
           yu = -xmax*Cx/Cy+0.5/Cy;
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
           fprintf(MACRO,"MCline%d->SetLineColor(3);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         } else {
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,2.*CxMC[i],ymin,2.*CxMC[i],ymax);
           fprintf(MACRO,"MCline%d->SetLineColor(2);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         }
        }  else {



           fprintf(MACRO,
     "TEllipse* MCcerchio%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMCcerchio%d->SetLineColor(3);\n",
                     i,cx/gamma,cy/gamma,Rr/fabs(gamma),Rr/fabs(gamma),i);
           fprintf(MACRO,
 "MCcerchio%d->SetFillStyle(0);\nMCcerchio%d->SetLineStyle(2);\nMCcerchio%d->SetLineWidth(1);\nMCcerchio%d->Draw();\n",
                     i,i,i,i);

       }


    }


   }



     fprintf(MACRO,"}\n");
     fclose(MACRO);
       







    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMCspecial




//----------start of function PndSttTrackFinderReal::WriteMacroParallelAssociatedHits

  void PndSttTrackFinderReal::WriteMacroParallelAssociatedHits(
                   Double_t Ox,Double_t Oy,Double_t R,
                   UShort_t Nhits,
		   UShort_t ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
//		   UShort_t infoparal[nmaxHits],
                   Double_t info[][7], Int_t Nincl, Int_t Minclinations[],
		   Double_t inclination[][3],
                   UShort_t imaxima,
		   Int_t sequencial
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];





//    Ox = (D+R)*cos(Fi);
//    Oy = (D+R)*sin(Fi);

//cout<<"da MacroTrackparalleletc. Ox, Oy "<<Ox<<",  "<<Oy<<endl;


//---------- parallel straws Macro now
      char nome[300], nome2[300];
      sprintf(nome,"MacroSttParEvent%dT%d", IVOLTE,sequencial);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( ii=0; ii< Nhits; ii++) {
            i = infoparal[  ListHitsinTrack[imaxima][ii]  ] ;
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

       fprintf(MACRO,"TEllipse* TC = new TEllipse(%f,%f,%f,%f,0.,360.);\n",Ox,Oy,R,R);
       fprintf(MACRO,"TC->SetLineColor(2);\nTC->SetFillStyle(0);\nTC->Draw();\n");

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( ii=0; ii< Nhits; ii++) {
            i = infoparal[  ListHitsinTrack[imaxima][ii]  ] ;
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
       }

      fprintf(MACRO,"}\n");
      fclose(MACRO);



       

    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelAssociatedHits
















//----------start of function PndSttTrackFinderReal::WriteMacroParallelAssociatedHitswithMC

  void PndSttTrackFinderReal::WriteMacroParallelAssociatedHitswithMC(
                   Double_t Ox,Double_t Oy,Double_t R,
                  Short_t TrackFoundaTrackMC,
                   UShort_t Nhits,
		UShort_t ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                   Double_t info[][7],
                   UShort_t ifoundtrack,
		Int_t sequentialNTrack,
		UShort_t nParalCommon[MAXTRACKSPEREVENT],
		UShort_t ParalCommonList[MAXTRACKSPEREVENT][nmaxHits],
		UShort_t nSpuriParinTrack[MAXTRACKSPEREVENT],
		UShort_t ParSpuriList[MAXTRACKSPEREVENT][nmaxHits],
		UShort_t nMCParalAlone[MAXTRACKSPEREVENT],
		UShort_t MCParalAloneList[MAXTRACKSPEREVENT][nmaxHits]
                                                     )
{

    Int_t i, j, i1, ii, index, imaxima, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];



	imaxima=ifoundtrack;

//    Ox = (D+R)*cos(Fi);
//    Oy = (D+R)*sin(Fi);

//cout<<"da MacroTrackparalleletc. Ox, Oy "<<Ox<<",  "<<Oy<<endl;


//---------- parallel straws Macro now
      char nome[300], nome2[300];
      sprintf(nome,"MacroSttParwithMCEvent%dT%d", IVOLTE,sequentialNTrack);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( ii=0; ii< Nhits; ii++) {
            i = infoparal[  ListHitsinTrack[imaxima][ii]  ] ;
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

       fprintf(MACRO,"TEllipse* TC = new TEllipse(%f,%f,%f,%f,0.,360.);\n",Ox,Oy,R,R);
       fprintf(MACRO,"TC->SetLineColor(2);\nTC->SetFillStyle(0);\nTC->Draw();\n");

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( ii=0; ii< nParalCommon[ifoundtrack]; ii++) {
            i = ParalCommonList[ifoundtrack][ii] ;
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i);
            fprintf(MACRO,"E%d->Draw();\n",i);
	}

       for( ii=0; ii< nSpuriParinTrack[ifoundtrack]; ii++) {
            i = ParSpuriList[ifoundtrack][ii] ;
            fprintf(MACRO,
         "TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i);
        	fprintf(MACRO,"E%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"E%d->Draw();\n",i);
       }

       for( ii=0; ii< nMCParalAlone[ifoundtrack]; ii++) {
            i = MCParalAloneList[ifoundtrack][ii] ;
            fprintf(MACRO,
         "TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i);
        	fprintf(MACRO,"E%d->SetLineColor(4);\n",i);
            fprintf(MACRO,"E%d->Draw();\n",i);
       }







//---------------------------  ora le tracce MC
	Int_t icode, im;
         Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica  ;
     PndMCTrack* pMC;
 if( TrackFoundaTrackMC > -1){
	im=TrackFoundaTrackMC;
		pMC = (PndMCTrack*) fMCTrackArray->At(im);
		if ( pMC ) {
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       if (icode>1000000000) carica = 1.;
       else  carica = fParticle->Charge()/3. ;    //   charge of track
	if( fabs(carica)<0.1) goto carica0 ;
           Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
            fprintf(MACRO,"TEllipse* MC%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMC%d->SetFillStyle(0);\nMC%d->SetLineColor(3);\nMC%d->Draw();\n",
                     im,Cx,Cy,Rr,Rr,im,im,im);
		}   //  end of if ( pMC )

 }  //  end of if( TrackFoundaTrackMC > -1){

//----------- fine parte del MC

carica0: ;


      fprintf(MACRO,"}\n");
      fclose(MACRO);



       

    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelAssociatedHitswithMC









































//----------start of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHits


  void PndSttTrackFinderReal::WriteMacroSkewAssociatedHits(
  		bool goodskewfit,
                   Double_t KAPPA,
                   Double_t FI0,
                   Double_t D,
                   Double_t Fi,
                   Double_t R,
                   Double_t info[][7],
                   Int_t Nincl,
                   Int_t Minclinations[],
                   Double_t inclination[][3],
                   Int_t imaxima,
		Int_t sequentialNTrack,
                   UShort_t nSkewHitsinTrack,
                   UShort_t ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits]
//                   UShort_t nSkewCommon,
//                   UShort_t SkewCommonList[MAXTRACKSPEREVENT][nmaxHits]

                                                     )


 {


    Int_t i, j, i1, ii, iii, index, Kincl, nlow, nup, STATUS, imc, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];





//-------------------  skew straws hits Macro now

      char  nome2[300],nome[300];
      FILE *MACRO;
      sprintf(nome,"MacroSttSkewEvent%dT%d",IVOLTE,sequentialNTrack);
      sprintf(nome2,  "%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);

//KAPPA = 1./166.67 ;  FI0 = 1.5*PI;

      Smin=zmin = 1.e10;
      Smax=zmax = -zmin;
      index=0;

       for( iii=0; iii< nSkewHitsinTrack; iii++) {
         i = infoskew[ ListSkewHitsinTrack[imaxima][iii] ];

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;

        if( distance >= info[i][4] + Aellipsis1) continue;


// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

/*
        if(
          fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
          distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
          ) {
cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
           continue;
          }
*/
//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);





// ------ se lo hit e' spurio marcalo in rosso
/*
        for( i1=0; i1<nSkewCommon; i1++){
          if ( SkewCommonList[   imaxima   ][i1] == i ){

                goto fuori ;
          }

        }
        fprintf(MACRO,"E%d->SetLineColor(2);\n",index);
fuori: ;

*/




        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( i=1; i< Nhits; i++)


  if(index==0) goto nohits ;
  if( zmax < zmin ) goto nohits ;
  if( Smax < Smin ) goto nohits;
  aaa = Smax-Smin;
  Smin -= aaa*1.;
  Smax += aaa*1.;

  aaa = zmax-zmin;
  zmin -= aaa*0.05;
  zmax += aaa*0.05;

  if(Smax > 2.*PI) Smax = 2.*PI;
  if( Smin < 0.) Smin = 0.;

//  Smin=0.;
//  Smax=2.*PI;


  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",zmin,Smin,zmax,Smax);
  for( ii=0; ii< index; ii++) {
       fprintf(MACRO,"E%d->Draw();\n",ii);
  }

   deltaz = zmax-zmin;
   deltaS = Smax-Smin;
   fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmax-0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,zmax-0.05*deltaz);
   fprintf(MACRO,"Assex->Draw();\n");
   fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,Smax-0.05*deltaS,Smin+0.05*deltaS,Smax-0.05*deltaS);
   fprintf(MACRO,"Assey->Draw();\n");




// --------------------------------

//  plot della traccia trovata dal finder
	if(!goodskewfit)goto niente ;
  if ( fabs(KAPPA) > 1.e-10 && fabs(KAPPA) < 1.e10  ) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
  	cout<<"PndSttTrackFinderReal::WriteMacroSkewAssociatedHits, this track found by PR not plotted"
	<<"\n\t because KAPPA = "<<KAPPA<<endl;
	goto niente ;
  }
  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }

  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
fprintf(MACRO,"TLine* FOUND%d = new TLine(%f,%f,%f,%f);\nFOUND%d->SetLineColor(2);\nFOUND%d->Draw();\n",
                 i-Nmin,z1,0.,z2, 2.*PI,i-Nmin,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


niente: ;
nohits: ;

      fprintf(MACRO,"}\n");
      fclose(MACRO);



}









//----------end of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHits







//----------start of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC




  void PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC(
  		bool goodskewfit,
                   Double_t KAPPA,
                   Double_t FI0,
                   Double_t D,
                   Double_t Fi,
                   Double_t R,
                   Double_t info[][7],
                   Int_t Nincl,
                   Int_t Minclinations[],
                   Double_t inclination[][3],
                   Int_t imaxima,
		   Int_t sequentialNTrack,
                   UShort_t nSkewHitsinTrack,
                   UShort_t ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                   UShort_t nSkewCommon,
                   UShort_t SkewCommonList[MAXTRACKSPEREVENT][nmaxHits],
                   UShort_t daTrackFoundaTrackMC,
		UShort_t nMCSkewAlone[MAXTRACKSPEREVENT],
		UShort_t MCSkewAloneList[MAXTRACKSPEREVENT][nmaxHits]
                                                     )
 {



    Int_t i, j, i1, ii, iii, index, Kincl, nlow, nup, STATUS, imc, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];


         TDatabasePDG *fdbPDG;
         TParticlePDG *fParticle;



//-------------------  skew straws hits Macro now

      char  nome2[300],nome[300];
      FILE *MACRO;
      sprintf(nome,  "MacroSttSkewwithMCEvent%dT%d", IVOLTE,sequentialNTrack);
      sprintf(nome2,  "%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);

//KAPPA = 1./166.67 ;  FI0 = 1.5*PI;

      Smin=zmin = 1.e10;
      Smax=zmax = -zmin;
      index=0;

//----------------------------
       for( iii=0; iii< nSkewHitsinTrack; iii++) {
         i = infoskew[ ListSkewHitsinTrack[imaxima][iii] ];

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;

        if( distance >= info[i][4] + Aellipsis1) continue;


// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
        fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);

// ------ se lo hit e' spurio marcalo in rosso
        for( i1=0; i1<nSkewCommon; i1++){
          if ( SkewCommonList[   imaxima   ][i1] == i ){

                goto fuori ;
          }

        }
        fprintf(MACRO,"E%d->SetLineColor(2);\n",index);
fuori: ;

        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( iii=0; iii< nSkewHitsinTrack; iii++)

//-------------------------------



//------ aggiungo in blu eventuali punti della traccia MC che sono non mecciati

       for( iii=0; iii< nMCSkewAlone[imaxima]; iii++) {
         i = MCSkewAloneList[imaxima][iii];

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;

        if( distance >= info[i][4] + Aellipsis1) continue;


// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

/*
        if(
          fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
          distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
          ) {
cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
           continue;
          }
*/
//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
        fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);

// ------  marca lo hit in blu
        fprintf(MACRO,"E%d->SetLineColor(4);\n",index);

        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( iii=0; iii< nMCSkewAlone[imaxima]; iii++)

//-------------------------------
//------ fine aggiunta in blu eventuali punti della traccia MC che sono non mecciati

  if(index==0) goto nohits ;
  if( zmax < zmin ) goto nohits ;
  if( Smax < Smin ) goto nohits;
  aaa = Smax-Smin;
  Smin -= aaa*1.;
  Smax += aaa*1.;

  aaa = zmax-zmin;
  zmin -= aaa*0.05;
  zmax += aaa*0.05;

  if(Smax > 2.*PI) Smax = 2.*PI;
  if( Smin < 0.) Smin = 0.;

//  Smin=0.;
//  Smax=2.*PI;


  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",zmin,Smin,zmax,Smax);
  for( ii=0; ii< index; ii++) {
       fprintf(MACRO,"E%d->Draw();\n",ii);
  }

   deltaz = zmax-zmin;
   deltaS = Smax-Smin;
   fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmax-0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,zmax-0.05*deltaz);
   fprintf(MACRO,"Assex->Draw();\n");
   fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,Smax-0.05*deltaS,Smin+0.05*deltaS,Smax-0.05*deltaS);
   fprintf(MACRO,"Assey->Draw();\n");




// --------------------------------

//  plot della traccia trovata dal finder

	if(!goodskewfit) goto nulla ;
  if ( fabs(KAPPA) > 1.e-10 && fabs(KAPPA) < 1.e10) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
  cout<<"PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC, this track found by PR not plotted"
	<<"\n\t because KAPPA = "<<KAPPA<<endl;
	goto nulla ;
  }

  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }


  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* FOUND%d = new TLine(%f,%f,%f,%f);\nFOUND%d->SetLineColor(2);\nFOUND%d->Draw();\n",
                 i-Nmin,z1,0.,z2, 2.*PI,i-Nmin,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)

nulla: ;
//---------------------------------------------  qui ci aggiungo le traccie MC


// for(imc=0; imc<nMCTracks ; imc++){
//            if(imc !=    daTrackFoundaTrackMC[ imaxima ]) continue;
     imc=    daTrackFoundaTrackMC ;

		Int_t icode;
        	Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica  ;
    		PndMCTrack* pMC;
		pMC = (PndMCTrack*) fMCTrackArray->At(imc);
		if ( ! pMC ) goto nohits ;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         	fdbPDG= TDatabasePDG::Instance();
		fParticle= fdbPDG->GetParticle(icode);
       		if (icode>1000000000) carica = 1.;
       		else  carica = fParticle->Charge()/3. ;    //   charge of track
		if( fabs(carica)<0.1) goto carica0 ;

           	Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           	Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
    		if( fabs( pMC->GetMomentum().Z() )< 1.e-20) KAPPA = 99999999.;
    		else  KAPPA = -carica*0.001*BFIELD*CVEL/pMC->GetMomentum().Z();
     		FI0 = fmod(Fifi+ PI, 2.*PI);

  if ( fabs(KAPPA) > 1.e-10  && fabs(KAPPA) < 1.e10) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
cout<<"PndSttTrackFinderReal::WriteMacroSkewAssociatedHits, this track found by PR not plotted"
	<<"\n\t because KAPPA = "<<KAPPA<<endl;
	goto nix ;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }

  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* MC%d_%d = new TLine(%f,%f,%f,%f);\nMC%d_%d->SetLineColor(3);\nMC%d_%d->Draw();\n",
                 imc,i-Nmin,z1,0.,z2, 2.*PI,imc,i-Nmin,imc,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)






nix: ;



carica0: ;
nohits: ;

      fprintf(MACRO,"}\n");
      fclose(MACRO);





 }


//----------end of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC




//----------begin of function PndSttTrackFinderReal::PndSttfromXYtoConformal

 void PndSttTrackFinderReal::PndSttFromXYtoConformal(Double_t trajectory_vertex[3],
                            Double_t info[][7],
                            Int_t Nparal,Double_t infoparalConformal[][5],
                            Int_t *status )
{


//   do the transformation in the conformal space :  u= x/(x**2+y**2), v= y/(x**2+y**2) for each hit from parallel
//   straws;  also the equidrift radius changes.

//

    Double_t gamma, x, y, r;

    for(int i=0; i<Nparal; i++){
            x = info[infoparal[i]][0]-trajectory_vertex[0];
            y = info[infoparal[i]][1]-trajectory_vertex[1];
            r = info[infoparal[i]][3];
            gamma = x*x + y*y - r*r;
            if(fabs( gamma ) < 1.e-10) {
              *status = -1;
              continue;
            }
            infoparalConformal[i][0] = x / gamma;
            infoparalConformal[i][1] = y / gamma;
            infoparalConformal[i][2] = r/fabs(gamma);
            infoparalConformal[i][3] = infoparal[i] ;      //  n. of the Hit (in the original order)
            infoparalConformal[i][4] = StrawRadius/fabs(gamma);

    }


   *status=0;
   return;
}

//----------end of function PndSttTrackFinderReal::PndSttfromXYtoConformal









//----------start function PndSttTrackFinderReal::PndSttfromXYtoConformal2

 void PndSttTrackFinderReal::PndSttFromXYtoConformal2(
                                Double_t trajectory_vertex[3],
                                UShort_t nHitsinTrack ,
                                UShort_t iExclude ,
                                UShort_t *ListHits,
                                Double_t info[][7],
                                Double_t auxinfoparalConformal[][5],
                                Int_t * status
                                                     )
{


//   do the transformation in the conformal space :  u= x/(x**2+y**2), v= y/(x**2+y**2) for each hit from parallel
//   straws;  also the equidrift radius changes.

//

    Double_t gamma, x, y, r;

    for(int i=0; i<nHitsinTrack; i++){
            if( i == iExclude) continue;
            x = info[  infoparal[ListHits[i]]  ][0]-trajectory_vertex[0];
            y = info[  infoparal[ListHits[i]]  ][1]-trajectory_vertex[1];
            r = info[  infoparal[ListHits[i]]  ][3];
            gamma = x*x + y*y - r*r;
            if(fabs( gamma ) < 1.e-10) {
              *status = -1;
              continue;
            }
            auxinfoparalConformal[i][0] = x / gamma;
            auxinfoparalConformal[i][1] = y / gamma;
            auxinfoparalConformal[i][2] = r/fabs(gamma);
            auxinfoparalConformal[i][3] = infoparal[ListHits[i]] ;      //  n. of the Hit (in the original order)
            auxinfoparalConformal[i][4] = StrawRadius/fabs(gamma);


    }



   *status=0;
   return;
}

//----------end of function PndSttTrackFinderReal::PndSttfromXYtoConformal2



















//----------begin of function PndSttTrackFinderReal::PndSttBoxConformalFilling

 void  PndSttTrackFinderReal::PndSttBoxConformalFilling(
			bool ExclusionList[nmaxHits],
			Double_t infoparalConformal[][5],Int_t Nparal,
			UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
			UShort_t HitsinBoxConformal[][nRdivConformal][nFidivConformal],
			UShort_t  RConformalIndex[nmaxHits],
			UShort_t  FiConformalIndex[nmaxHits]
							)
{

    Short_t iR, iFi, i, j;
    Double_t Fi;



      for(i = 0; i< nRdivConformalEffective ; i++){
        for(j = 0; j< nFidivConformal ; j++){
           nBoxConformal[i][j]= 0;
        }
      }

      for(i = 0; i< Nparal ; i++){
	 if( ! ExclusionList[ infoparal[i] ] ) continue;
         Fi =  atan2(infoparalConformal[i][1],infoparalConformal[i][0]) ;
         if ( Fi < 0. ) Fi += 2.*PI;
         iFi =  (Short_t) (0.5*nFidivConformal*Fi/PI);
         if(iFi > nFidivConformal ) {
            iFi = nFidivConformal;
         } else if (iFi<0) {
            iFi = 0;
         }


         Double_t RRR = sqrt(infoparalConformal[i][0]*infoparalConformal[i][0]+infoparalConformal[i][1]*infoparalConformal[i][1]);
//   cout<<"from Fillng : hit parallel n. "<<i<<"  con raggio conforme "<<RRR<<endl;

         for(j=nRdivConformalEffective-1, iR=0; j>0; j--){
           if( RRR> radiaConf[j] ){
              iR = j;
              break;
           }
         }
	 if( nBoxConformal[iR][iFi] >= MAXHITSINCELL ){
		cout<<"Warning from PndSttTrackFinderReal::PndSttBoxConformalFilling     :"
	<<"\n\tcontent in nBoxConformal["<<iR<<"]["<<iFi<<"] has reached the Max allowed value = "
	<<MAXHITSINCELL<<endl;
		 continue;
	 }
         HitsinBoxConformal[ nBoxConformal[iR][iFi] ][iR][iFi]=(UShort_t) i;
         nBoxConformal[iR][iFi]++;
         RConformalIndex[ infoparal[i] ]  =  iR;
         FiConformalIndex[ infoparal[i] ]  =  iFi;
      }	// end of for(i = 0; i< Nparal ; i++)



    return;

}
//----------end of function PndSttTrackFinderReal::PndSttBoxConformalFilling



//----------begin of function PndSttTrackFinderReal::Merge_Sort



void PndSttTrackFinderReal::Merge_Sort(UShort_t n_ele, Double_t *array, UShort_t *ind)
{


//  this method orders a set of numbers from smaller to biggers; smaller numbers come first.
//  The vector :    array     is going to be changed, and also the vector   ind  will be changed
//  accordingly.


  UShort_t nr, nl, middle, i,
           ind_left[n_ele], ind_right[n_ele];

  Double_t left[n_ele], right[n_ele], result[n_ele];

   if( n_ele <= 1)  return;

   middle = n_ele/2 ;
   for(i=0; i<middle; i++){
     left[i]=array[i];
     ind_left[i]= ind[i];
   }
   for(i=middle; i<n_ele; i++){
     right[i-middle]=array[i];
     ind_right[i-middle]= ind[i];
   }

   Merge_Sort( middle,  left, ind_left);
   Merge_Sort(n_ele-middle, right, ind_right);

   if( left[middle-1] > right[0]) {
     Merge(middle, left,ind_left, n_ele-middle, right, ind_right, array, ind);
   }  else {
     //  do the appending
     for(i=0; i<middle; i++){
       array[i]=left[i];
       ind[i]=ind_left[i];

     }
     for(i=middle; i<n_ele; i++){
       array[i]=right[i-middle];
       ind[i]=ind_right[i-middle];
     }
   }


}


//----------end of function PndSttTrackFinderReal::Merge_Sort


//----------begin of function PndSttTrackFinderReal::Merge




void PndSttTrackFinderReal::Merge(UShort_t nl, Double_t *left, UShort_t *ind_left, UShort_t nr,
                                         Double_t *right, UShort_t *ind_right,  Double_t *result, UShort_t *ind)
{
   UShort_t i =0, j, nl_curr=0, nr_curr=0;

   while( nl > 0 && nr >0){
     if( left[nl_curr] <= right[nr_curr]){
      result[i] =  left[nl_curr];
      ind[i] = ind_left[nl_curr];
      nl--;
      nl_curr++;
     } else {
      result[i] =  right [nr_curr];
      ind[i] =  ind_right [nr_curr];
      nr--;
      nr_curr++;
     }
    i++;
   }
//--------------------
   if( nl ==0) {
     for(j=0; j<nr; j++){
      result[i+j]= right[nr_curr+j];
      ind[i+j]= ind_right[nr_curr+j];
     }
   }   else {
     for(j=0; j<nl; j++){
      result[i+j]= left[nl_curr+j];
      ind[i+j]= ind_left[nl_curr+j];
     }
   }





}

//----------end of function PndSttTrackFinderReal::Merge





//----------begin of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformal


  Short_t PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformal(
                                                  UShort_t NRCELLDISTANCE,
                                                  UShort_t NFiCELLDISTANCE,
                                                  UShort_t Nparal,
                                                  UShort_t ihit,
                                                  Double_t info[][7],
                                                  bool ExclusionList[nmaxHits],
                                                  UShort_t RConformalIndex[nmaxHits],
                                                  UShort_t FiConformalIndex[nmaxHits],
                                                  UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                                                  UShort_t HitsinBoxConformal[][nRdivConformal][nFidivConformal],
                                                  UShort_t *ListHitsinTrack
                                                                      )
{





     bool TemporaryExclusionList[nmaxHits];

     UShort_t i, j, iR, iFi, nRmin, nRmax, nRemainingHits, nRcell, nFicell, nHitsinTrack,
                 Remaining[nmaxHits],
                 auxIndex[nmaxHits];

     Short_t iFi2;

     Double_t auxRvalues[nmaxHits];

//   ihit        is the hit number in the PARALLEL number scheme




     for(i=0, nRemainingHits=0; i<Nparal; i++){

        if( i != ihit && ExclusionList[  infoparal[i]   ] ) {   //  exclusion of the parallel hit straws already used in other tracks
                                                           //  remember the index of ExclusionList is in the ORIGINAL scheme of hits
            TemporaryExclusionList[ infoparal[i]  ]= true;
            Remaining[nRemainingHits]= i;   //  index of the PARALLEL hit
            nRemainingHits++;
        } else {
            TemporaryExclusionList[ infoparal[i]  ]= false;
        }

     }


     if( nRemainingHits < MINIMUMHITSPERTRACK )    return 0;



//  cells of the seed hit

    nHitsinTrack=1;
    ListHitsinTrack[0]=  ihit ;

   i = 0;
   while( nRemainingHits > 0 &&  i < nHitsinTrack) {

    nRcell = RConformalIndex[   infoparal[  ListHitsinTrack[i] ]   ];
    nFicell = FiConformalIndex[  infoparal[  ListHitsinTrack[i]  ]  ];

// if(IVOLTE==3)cout<<"nRcell = "<<nRcell<<", nFicell = "<< nFicell<<endl;


//---------------

    if (nRcell - NRCELLDISTANCE < 0 ) {
      nRmin = 0;
    }  else {
      nRmin = nRcell - NRCELLDISTANCE;
    }
    if (nRcell + NRCELLDISTANCE >= nRdivConformalEffective ) {
      nRmax = nRdivConformalEffective-1;
    }  else {
      nRmax = nRcell + NRCELLDISTANCE;
    }


    for( iR= nRmin ; iR<= nRmax ; iR++){
      for( iFi2 = nFicell - NFiCELLDISTANCE ; iFi2<= nFicell + NFiCELLDISTANCE ; iFi2++){
          if ( iFi2 < 0 )  {
            iFi = nFidivConformal + iFi2;
          } else if ( iFi2 >= nFidivConformal) {
            iFi = iFi2  - nFidivConformal;
          }  else {
            iFi = iFi2;
          }
         for (j = 0; j< nBoxConformal[iR][iFi]; j++){
          if( ExclusionList[  infoparal[  HitsinBoxConformal[j][iR][iFi]  ]  ]
                                      &&
              TemporaryExclusionList[   infoparal[  HitsinBoxConformal[j][iR][iFi]  ]   ]) {
            ListHitsinTrack[nHitsinTrack]=HitsinBoxConformal[j][iR][iFi] ;   //  hit number in the PARALLEL straws scheme
//if(IVOLTE==3)   cout<<"\tnFi cell di hit accettato "<<iFi<<" e iR di hit accettato = "<<iR<<endl;

            nHitsinTrack++;
            TemporaryExclusionList[ infoparal[  HitsinBoxConformal[j][iR][iFi]  ]  ]= false;
            nRemainingHits--;
          }
         }
      }
    }
//----------------
    i++;


   }    //  end      while ( nRemainingHits > 0 && i < nHitsinTrack)





    return nHitsinTrack;

}


//----------end of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformal


//----------begin of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformalSpecial


  Short_t PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformalSpecial(
                                                  UShort_t NRCELLDISTANCE,
                                                  UShort_t NFiCELLDISTANCE,                                                  
                                                  UShort_t Nparal,
                                                  UShort_t NparallelToSearch,
                                                  UShort_t iSeed,
                                                  UShort_t *ListHitsinTrackinWhichToSearch,
                                                  Double_t info[][7],
                                                  bool ExclusionList[nmaxHits],
                                                  UShort_t RConformalIndex[nmaxHits],
                                                  UShort_t FiConformalIndex[nmaxHits],
                                                  UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                                                  UShort_t HitsinBoxConformal[][nRdivConformal][nFidivConformal],
                                                  UShort_t  *OutputListHitsinTrack
                                                                      )
{





     bool TemporaryExclusionList[nmaxHits];

     UShort_t i, i2, j, iR, iFi, nRmin, nRmax, nRemainingHits, nRcell, nFicell, nHitsinTrack,
                 Remaining[nmaxHits],
                 auxIndex[nmaxHits];

     Short_t iFi2;

     Double_t auxRvalues[nmaxHits];

//   iSeed        is the hit number in the PARALLEL number scheme

//cout<<" Nparal "<<Nparal<<",  NparallelToSearch "<<NparallelToSearch<<
//", iSeed   "<<iSeed<< endl;
//--------    the following initialization is essential for the algorithm to work
     for(i=0; i<Nparal; i++){
       TemporaryExclusionList[ infoparal[i]  ]= false;
     }
//-------------

     for(i2=0, nRemainingHits=0; i2<NparallelToSearch; i2++){
        i=ListHitsinTrackinWhichToSearch[i2];
        if( i != iSeed && ExclusionList[  infoparal[i]   ] ) {   //  exclusion of the parallel hit straws already used in other tracks
                                                           //  remember the index of ExclusionList is in the ORIGINAL scheme of hits
            TemporaryExclusionList[ infoparal[i]  ]= true;
            Remaining[nRemainingHits]= i;   //  index of the PARALLEL hit
            nRemainingHits++;
        } 

     }


     if( nRemainingHits < MINIMUMHITSPERTRACK )    return 0;

//  cells of the seed hit

    nHitsinTrack=1;
    OutputListHitsinTrack[0]=  iSeed ;
//cout<<"From PatterninBoxConformal -------------------- hit seed n. (orig.) "<<OutputListHitsinTrack[0]<<endl;
   i = 0;
   while( nRemainingHits > 0 &&  i < nHitsinTrack) {

    nRcell = RConformalIndex[   infoparal[  OutputListHitsinTrack[i] ]   ];
    nFicell = FiConformalIndex[  infoparal[  OutputListHitsinTrack[i]  ]  ];
//cout<<"From PatterninBoxConformal HIT collezionatore ora ha nRcell e nFicell "<<nRcell<<",  "<< nFicell<<endl;

//---------------

    if (nRcell - NRCELLDISTANCE < 0 ) {
      nRmin = 0;
    }  else {
      nRmin = nRcell - NRCELLDISTANCE;
    }
    if (nRcell + NRCELLDISTANCE >= nRdivConformalEffective ) {
      nRmax = nRdivConformalEffective-1;
    }  else {
      nRmax = nRcell + NRCELLDISTANCE;
    }

//cout <<"    di conseguenza ora nRmin e  nRmax sono : "<<nRmin<<",  "<<nRmax<<endl;

    for( iR= nRmin ; iR<= nRmax ; iR++){
      for( iFi2 = nFicell - NFiCELLDISTANCE ; iFi2<= nFicell + NFiCELLDISTANCE ; iFi2++){
          if ( iFi2 < 0 )  {
            iFi = nFidivConformal + iFi2;
          } else if ( iFi2 >= nFidivConformal) {
            iFi = iFi2  - nFidivConformal;
          }  else {
            iFi = iFi2;
          }
         for (j = 0; j< nBoxConformal[iR][iFi]; j++){
          if( ExclusionList[  infoparal[  HitsinBoxConformal[j][iR][iFi]  ]  ]
                                      &&
              TemporaryExclusionList[   infoparal[  HitsinBoxConformal[j][iR][iFi]  ]   ]) {
            OutputListHitsinTrack[nHitsinTrack]=HitsinBoxConformal[j][iR][iFi] ;   //  hit number in the PARALLEL straws scheme
            nHitsinTrack++;
            TemporaryExclusionList[ infoparal[  HitsinBoxConformal[j][iR][iFi]  ]  ]= false;
            nRemainingHits--;
          }
         }
      }
    }
//----------------
    i++;

   }    //  end      while ( nRemainingHits > 0 && i < nHitsinTrack)






    return nHitsinTrack;

}


//----------end of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformalSpecial






//----------begin of function PndSttTrackFinderReal::PndSttFindTrackStrictCollection


  Short_t PndSttTrackFinderReal::PndSttFindTrackStrictCollection(
                                                  UShort_t NFiCELLDISTANCE,                                                  
                                                  UShort_t iSeed,   //  seed track (parallel notation) as fa as the Fi angle is concerned
                                                  UShort_t NParallelToSearch,    //  n. of hits to search in ListHitsinTrackinWhichToSearch
                                                  UShort_t *ListHitsinTrackinWhichToSearch,
                                                  bool ExclusionList[nmaxHits],
                                                  UShort_t FiConformalIndex[nmaxHits],
                                                  UShort_t  *OutputListHitsinTrack
                                                                      )
{






     UShort_t i,  j, iR, iFi,  iFiseed, nHitsinTrack;


     Double_t auxRvalues[nmaxHits];


if(istampa>=3 && IVOLTE <= nmassimo) {
     cout<<"Da strictcollection, n. elementi delle search list "<<NParallelToSearch<<endl;
     for(i=0; i<NParallelToSearch; i++){
        cout<<"Da strictcollection,  hit n. (parallel notation ) "<<ListHitsinTrackinWhichToSearch[i]<<endl;
     }
}


//   iSeed        is the hit number in the PARALLEL number scheme

     iFiseed = FiConformalIndex[ infoparal[  iSeed ] ];
if(istampa>=3 && IVOLTE <= nmassimo)cout<<"Da strictcollection, iFiseed "<<iFiseed<<endl;

     nHitsinTrack=0;
     for(i=0; i<NParallelToSearch; i++){
        if( ExclusionList[  infoparal[ ListHitsinTrackinWhichToSearch[i] ]   ] ) {   //  exclusion of the parallel hit straws already used in other tracks
                                                           //  remember the index of ExclusionList is in the ORIGINAL scheme of hits

          iFi = FiConformalIndex[ infoparal[  ListHitsinTrackinWhichToSearch[i] ] ];
          if( iFi == iFiseed ) {
            OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
            nHitsinTrack++;
          } else if ( iFi < iFiseed ) {
            if( iFiseed - iFi <= NFiCELLDISTANCE ) {
              OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
              nHitsinTrack++;
            }  else {
               if( iFi + nFidivConformal - iFiseed<= NFiCELLDISTANCE ) {
                 OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
                 nHitsinTrack++;
               }
            }
          }   else {   //  iFi > iFiseed
            if( -iFiseed + iFi <= NFiCELLDISTANCE ) {
              OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
              nHitsinTrack++;
            }  else {
               if( -iFi + nFidivConformal + iFiseed<= NFiCELLDISTANCE ) {
                 OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
                 nHitsinTrack++;
               }
            }

          }   //  end of   if( iFi == iFiseed )

        }    //  end of    if( ExclusionList[  infoparal[ ListHitsinTrackinWhichToSearch[i] ]   ] )

     }   //  end of        for(i=0; i<NparallelToSearch; i++)


if(istampa>=3 && IVOLTE <= nmassimo) {
     cout<<"Da strictcollection, n. elementi aggiunti "<<nHitsinTrack<<endl;
     for(i=0; i<nHitsinTrack; i++){
       cout<<"Da strictcollection,  hit n. (parallel notaion ) "<<OutputListHitsinTrack[i]<<endl;
     }
}

    return nHitsinTrack;

}


//----------end of function PndSttTrackFinderReal::PndSttFindTrackStrictCollection








//----------begin of function PndSttTrackFinderReal::PndSttFitHelixCylinder

      Short_t PndSttTrackFinderReal::PndSttFitHelixCylinder( UShort_t nHitsinTrack,
                                                     Double_t auxinfoparalConformal[][5],
                                                     UShort_t  nTracksFoundSoFar,
                                                     Double_t rotationangle,
                                                     Double_t * trajectory_vertex,
                                                     UShort_t NMAX,
                                                     Double_t *emme,
                                                     Double_t *qu,
                                                     Double_t *ALFA,
                                                     Double_t *BETA,
                                                     Double_t *GAMMA,
                                                     bool *TypeConf
                                                            )
{

    //   definition of variables for the glpsol  solver
   //    ROWS (for read_rows  function)
   //
   UShort_t  NpointsInFit = nHitsinTrack-NMAX <0 ?  nHitsinTrack :  NMAX;
   int    nRows= NpointsInFit*9 +1;
   int typeRows[nRows];
   char * nameRows[nRows];
   char  auxnameRows[nRows][20];
//-------  end ROWS information
//--------begin COLUMNS information
      int  NStructVar=5+NpointsInFit*4;  //  number of  structural variables
      int  NStructRows = 8*NpointsInFit ;  //  maximum number of ROWS in which a structural variable can be found
      double final_values[NStructVar];
      int  NRowsInWhichStructVarArePresent[NStructVar];
      char *StructVarName[NStructVar];
      char auxStructVarName[NStructVar][20];
//      char *AuxNameRowsInWhichStructVarArePresent[NStructVar][NStructRows];
      char *NameRowsInWhichStructVarArePresent[NStructVar*NStructRows];
      char aux[NStructVar*NStructRows][20];
//      double Coefficients[NStructVar][NStructRows];
      double Coefficients[NStructVar*NStructRows];
//--------end COLUMNS information
//--------begin RHS information
      double ValueB[9*NpointsInFit];
//--------end RHS information
//--------begin RANGES information
      int nRanges = NpointsInFit;
      double ValueRanges[nRanges];
      char *NameRanges[nRanges];
      char auxNameRanges[nRanges][20];
//--------end RANGES information
//--------start BOUNDS information
      int nBounds=2*NpointsInFit+1;
      double BoundValue[nBounds];
      char *BoundStructVarName[nBounds];
      char auxBoundStructVarName[nBounds][20];
      char *TypeofBound[nBounds];
      char auxTypeofBound[nBounds][20];
//--------end BOUNDS information




     Double_t M = 1.,
              m_result,
              q_result,
              A,
              alfetta,
              angle,
              offsety,
              Delta[nmaxHits],
              Ox[nmaxHits],
              Oy[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

//     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --

     if( nHitsinTrack < MINIMUMHITSPERTRACK) {
        return -1;
     }

//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
      rotationangle -= PI/18.;

      Double_t cose = cos(rotationangle), sine = sin(rotationangle);
      for(i=0;i<nHitsinTrack; i++){
//       if( i== iExclude)  continue;
       Ox[i] = auxinfoparalConformal[ i ][0] *cose +
               auxinfoparalConformal[ i ][1]*sine;
       Oy[i] = -auxinfoparalConformal[ i ][0] *sine +
               auxinfoparalConformal[ i ][1]*cose;

//cout<<"dal fitter, hit in lista sequenziale, n. "<<i<<",  Ox , Oy ruotati "<<Ox[i]<<",  "<<Oy[i]<<"  drift radius  "
//     <<auxinfoparalConformal[ i ][2]<<"   and  straw radisu  "<<auxinfoparalConformal[ i ][4]<<endl;



//  now traslate toward positive V values to obtain always positive q values
//       offsety = 10./RStrawDetectorMin;
//       Oy[i] += offsety;



//         Delta[i] = auxinfoparalConformal[ i ][4];
         
        if( auxinfoparalConformal[ i ][2] > 1.e-10) {
          Delta[i] = 3.*auxinfoparalConformal[ i ][2];   //   3 times the Drift Radius
        } else {
          Delta[i] = 3.*StrawRadius;
        }
      }

//      sprintf(nome,"GeneralParallelHitsConformeTraccia%dEvent%d.mcs",(nTracksFoundSoFar), IVOLTE);
//      MACRO = fopen(nome,"w");
//      fprintf(MACRO,"NAME    FIT\n");
//-----------------  write the ROWS  section

/*
      fprintf(MACRO,"ROWS\n");
      fprintf(MACRO," N OBJECT\n");
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
           fprintf(MACRO," L Ap%d\n L Bp%d\n L Cp%d\n L Dp%d\n",i,i,i,i);
           fprintf(MACRO," L Am%d\n L Bm%d\n L Cm%d\n L Dm%d\n G LAMBDA%d\n",i,i,i,i,i);
      }

*/

//--------
//      nameRows[0]="OBJECT";
      sprintf(&(auxnameRows[0][0]),"OBJECT",i);  nameRows[0]=&auxnameRows[0][0];
      typeRows[0]=GLP_FR;
      for(i=0 ; i< NpointsInFit ; i++) {
       ii=9*i;

       typeRows[1+ii]=GLP_UP;typeRows[2+ii]=GLP_UP;typeRows[3+ii]=GLP_UP;typeRows[4+ii]=GLP_UP;
       typeRows[5+ii]=GLP_UP;typeRows[6+ii]=GLP_UP;typeRows[7+ii]=GLP_UP;typeRows[8+ii]=GLP_UP;
       typeRows[9+ii]=GLP_LO;

       sprintf(&(auxnameRows[1+ii][0]),"Ap%d",i);  nameRows[1+ii]=&auxnameRows[1+ii][0];
       sprintf(&(auxnameRows[2+ii][0]),"Bp%d",i);  nameRows[2+ii]=&auxnameRows[2+ii][0];
       sprintf(&(auxnameRows[3+ii][0]),"Cp%d",i);  nameRows[3+ii]=&auxnameRows[3+ii][0];
       sprintf(&(auxnameRows[4+ii][0]),"Dp%d",i);  nameRows[4+ii]=&auxnameRows[4+ii][0];
       sprintf(&(auxnameRows[5+ii][0]),"Am%d",i);  nameRows[5+ii]=&auxnameRows[5+ii][0];
       sprintf(&(auxnameRows[6+ii][0]),"Bm%d",i);  nameRows[6+ii]=&auxnameRows[6+ii][0];
       sprintf(&(auxnameRows[7+ii][0]),"Cm%d",i);  nameRows[7+ii]=&auxnameRows[7+ii][0];
       sprintf(&(auxnameRows[8+ii][0]),"Dm%d",i);  nameRows[8+ii]=&auxnameRows[8+ii][0];
       sprintf(&(auxnameRows[9+ii][0]),"LAMBDA%d",i);  nameRows[9+ii]=&auxnameRows[9+ii][0];
      }




//-----------------  write the COLUMNS  section

//      fprintf(MACRO,"COLUMNS\n");

//  Column variable  m1


      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
//          fprintf(MACRO,"  m1 Ap%d  %g  Am%d  %g\n  m1 Bp%d  %g   Bm%d  %g\n",
//                                  i,Ox[i],i,Ox[i],i,-Ox[i],i,-Ox[i]);
        Coefficients[i*4]=    Ox[i];
        Coefficients[i*4+1]=  Ox[i];
        Coefficients[i*4+2]= -Ox[i];
        Coefficients[i*4+3]= -Ox[i];
      }



//  Column variable  m2
      for(i=0; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  m2 Ap%d  %g  Am%d  %g\n  m2 Bp%d  %g   Bm%d  %g\n",
//                                  i,-Ox[i],i,-Ox[i],i,Ox[i],i,Ox[i]);
        Coefficients[NStructRows+i*4]=   -Ox[i];
        Coefficients[NStructRows+i*4+1]= -Ox[i];
        Coefficients[NStructRows+i*4+2]= Ox[i];
        Coefficients[NStructRows+i*4+3]= Ox[i];

      }

//  Column variable  q1
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  q1 Ap%d   1.  Am%d   1.\n  q1 Bp%d  -1.  Bm%d  -1.\n",
//                                  i,i,i,i);
        Coefficients[2*NStructRows+i*4]=    1.;
        Coefficients[2*NStructRows+i*4+1]=  1.;
        Coefficients[2*NStructRows+i*4+2]= -1.;
        Coefficients[2*NStructRows+i*4+3]= -1.;
      }

//  Column variable  q2
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  q2 Ap%d   -1.  Am%d   -1.\n  q2 Bp%d   1.   Bm%d   1.\n",
//                                  i,i,i,i);
        Coefficients[3*NStructRows+i*4]=   -1.;
        Coefficients[3*NStructRows+i*4+1]= -1.;
        Coefficients[3*NStructRows+i*4+2]=  1.;
        Coefficients[3*NStructRows+i*4+3]=  1.;
      }

//  Column variable  lambdap(i)
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  lamp%d  Ap%d  %g  Bp%d  %g\n  lamp%d  Cp%d  %g  Dp%d   %g\n  lamp%d  LAMBDA%d  1.\n",
//                                                i,i,-M,i,-M, i , i,-M, i, M, i,i);
        Coefficients[(4+i)*NStructRows+0]= -M;
        Coefficients[(4+i)*NStructRows+1]= -M;
        Coefficients[(4+i)*NStructRows+2]= -M;
        Coefficients[(4+i)*NStructRows+3]=  M;
        Coefficients[(4+i)*NStructRows+4]=  1.;
      }
//  Column variable  lambdam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  lamm%d  Am%d  %g  Bm%d  %g\n  lamm%d  Cm%d  %g  Dm%d %g\n  lamm%d  LAMBDA%d  1.\n",
//                                                i,i,-M,i,-M, i,i , -M, i, M, i,i);
        Coefficients[(4+i+NpointsInFit)*NStructRows+0]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+1]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+2]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+3]=  M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+4]=  1.;
      }
//  Column variable  sigmap(i)
      for(i=0; i< NpointsInFit ; i++) {

//          fprintf(MACRO,"  sigmap%d  OBJECT  %g  Ap%d  -1.\n  sigmap%d  Bp%d    -1. Cp%d  1.\n  sigmap%d  Dp%d -1.\n",
//                                                i,1./Delta[i],i,i,i,i,i,i);
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+4]= -1.;
      }
//  Column variable  sigmam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  sigmam%d  OBJECT %g  Am%d  -1.\n  sigmam%d  Bm%d   -1. Cm%d   1.\n  sigmam%d  Dm%d  -1.\n",
//                                                i,1./Delta[i],i,i,i,i,i,i);
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+4]= -1.;
      }

//  Column variable  DUMMY
/*
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
        fprintf(MACRO,"  DUMMY     Ap%d  1.      Am%d       1.\n  DUMMY   Bp%d   1.    Bm%d   1.\n  DUMMY    Cp%d   1.   Cm%d   1\n",
                                                i,i,i,i,i,i);
        fprintf(MACRO,"  DUMMY     Dp%d  1.      Dm%d       1.\n",
                                                i,i);
      }
*/

      for(i=0 ; i< NStructRows ; i++) {
        Coefficients[(4+4*NpointsInFit)*NStructRows+i]= 1.;
      }
//--------------------
      sprintf(&auxStructVarName[0][0],"m1",i);
      StructVarName[0] = &auxStructVarName[0][0];
//      StructVarName[0]="m1";
      NRowsInWhichStructVarArePresent[0]= 4*NpointsInFit;

      sprintf(&auxStructVarName[1][0],"m2",i);
      StructVarName[1] = &auxStructVarName[1][0];
//      StructVarName[1]="m2";
      NRowsInWhichStructVarArePresent[1]= 4*NpointsInFit;

      sprintf(&auxStructVarName[2][0],"q1",i);
      StructVarName[2] = &auxStructVarName[2][0];
//      StructVarName[2]="q1";
      NRowsInWhichStructVarArePresent[2]= 4*NpointsInFit;

      sprintf(&auxStructVarName[3][0],"q2",i);
      StructVarName[3] = &auxStructVarName[3][0];
//      StructVarName[3]="q2";
      NRowsInWhichStructVarArePresent[3]= 4*NpointsInFit;
      for(i=0; i< NpointsInFit ; i++) {
          sprintf(&auxStructVarName[3+i+1][0],"lamp%d",i);
          StructVarName[4+i] = &auxStructVarName[4+i][0];
          NRowsInWhichStructVarArePresent[4+i]= 5;

          sprintf(&auxStructVarName[4+NpointsInFit+i][0],"lamm%d",i);
          StructVarName[4+NpointsInFit+i] = &auxStructVarName[4+NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+2*NpointsInFit+i][0],"sigmap%d",i);
          StructVarName[4+2*NpointsInFit+i] = &auxStructVarName[4+2*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+2*NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+3*NpointsInFit+i][0],"sigmam%d",i);
          StructVarName[4+3*NpointsInFit+i] = &auxStructVarName[4+3*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+3*NpointsInFit+i]= 5;

      }


      sprintf(&auxStructVarName[4+4*NpointsInFit][0],"DUMMY",i);
      StructVarName[4+4*NpointsInFit] = &auxStructVarName[4+4*NpointsInFit][0];
//      StructVarName[4+4*NpointsInFit]="DUMMY";
      NRowsInWhichStructVarArePresent[4+4*NpointsInFit]= NStructRows;


//  for m1, m2, q1, q2
      for(i=0; i< 4; i++){
        for(ii=0; ii< NpointsInFit;ii++){
         sprintf(&aux[i*NStructRows+ii*4][0],"Ap%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4]=&aux[i*NStructRows+ii*4][0];
         sprintf(&aux[i*NStructRows+ii*4+1][0],"Am%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+1]=&aux[i*NStructRows+ii*4+1][0];
         sprintf(&aux[i*NStructRows+ii*4+2][0],"Bp%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+2]=&aux[i*NStructRows+ii*4+2][0];
         sprintf(&aux[i*NStructRows+ii*4+3][0],"Bm%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+3]=&aux[i*NStructRows+ii*4+3][0];
        }
      }

//  now for the    lamp*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4)*NStructRows+0][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+0]= &aux[(i+4)*NStructRows+0][0];
         sprintf(&aux[(i+4)*NStructRows+1][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+1]= &aux[(i+4)*NStructRows+1][0];
         sprintf(&aux[(i+4)*NStructRows+2][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+2]= &aux[(i+4)*NStructRows+2][0];
         sprintf(&aux[(i+4)*NStructRows+3][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+3]= &aux[(i+4)*NStructRows+3][0];
         sprintf(&aux[(i+4)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+4]= &aux[(i+4)*NStructRows+4][0];
      }

//  now for the    lamm*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+0][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+0]= &aux[(i+4+NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+1][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+1]= &aux[(i+4+NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+2][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+2]= &aux[(i+4+NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+3][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+3]= &aux[(i+4+NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+4]= &aux[(i+4+NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmap*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+0]= &aux[(i+4+2*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+1][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+1]= &aux[(i+4+2*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+2][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+2]= &aux[(i+4+2*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+3][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+3]= &aux[(i+4+2*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+4][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+4]= &aux[(i+4+2*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmam*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+0]= &aux[(i+4+3*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+1][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+1]= &aux[(i+4+3*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+2][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+2]= &aux[(i+4+3*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+3][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+3]= &aux[(i+4+3*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+4][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+4]= &aux[(i+4+3*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    DUMMY   variable
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows  +8*i][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+i*8  ]= &aux[(4+4*NpointsInFit)*NStructRows  +8*i][0];

         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+1+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+2+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+3+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+4+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+5+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+6+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+7+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0];
      }



//-----------------  write the RHS  section

//      fprintf(MACRO,"RHS\n");
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  BOUND  Ap%d  %g  Bp%d  %g\n  BOUND  Cp%d  %g  Dp%d  %g\n",
//              i, Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
//                -Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
//                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);
          ValueB[i*9]  =  Oy[i]+auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+1]= -Oy[i]-auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+2]= Delta[i]+2.*M;
          ValueB[i*9+3]= M-Delta[i]+2.*M;


/*
          fprintf(MACRO,"  BOUND  Am%d  %g  Bm%d  %g\n  BOUND  Cm%d  %g  Dm%d %g\n",
              i, Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
                -Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);
          fprintf(MACRO,"  BOUND  LAMBDA%d   1.\n",i);
*/

          ValueB[i*9+4]=  Oy[i]-auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+5]= -Oy[i]+auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+6]= Delta[i]+2.*M;
          ValueB[i*9+7]= M-Delta[i]+2.*M;
          ValueB[i*9+8]= 1.;


      }


//-----------------  write the RANGES  section

//      fprintf(MACRO,"RANGES\n");
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  RANGE  LAMBDA%d  1.\n",i);
//---
        ValueRanges[i]=1.;
        sprintf(&auxNameRanges[i][0],"LAMBDA%d",i);
        NameRanges[i]=&auxNameRanges[i][0];
      }

//-----------------  write the BOUNDS  section

//      fprintf(MACRO,"BOUNDS\n");

      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO," BV  Bounds  lamp%d\n",  i);

          sprintf(&auxTypeofBound[i][0],"BV");   TypeofBound[i]= &auxTypeofBound[i][0];
//          TypeofBound[i]="BV";
          sprintf(&auxBoundStructVarName[i][0],"lamp%d",i);
          BoundStructVarName[i]=&auxBoundStructVarName[i][0];
          BoundValue[i]=0.;
      }

      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO," BV  Bounds  lamm%d\n", i);
          sprintf(&auxTypeofBound[i+NpointsInFit][0],"BV");
          TypeofBound[i+NpointsInFit]= &auxTypeofBound[i+NpointsInFit][0];
//          TypeofBound[i+NpointsInFit]="BV";
          sprintf(&auxBoundStructVarName[i+NpointsInFit][0],"lamm%d",i);
          BoundStructVarName[i+NpointsInFit]=&auxBoundStructVarName[i+NpointsInFit][0];
          BoundValue[i+NpointsInFit]=0.;
      }

//          fprintf(MACRO," FX  Bounds  DUMMY  %g\n",2.*M);
          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]= &auxTypeofBound[2*NpointsInFit][0];
//          TypeofBound[2*NpointsInFit]="FX";

          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]= &auxTypeofBound[2*NpointsInFit][0];

          sprintf(&auxBoundStructVarName[2*NpointsInFit][0],"DUMMY");
          BoundStructVarName[2*NpointsInFit]=&auxBoundStructVarName[2*NpointsInFit][0];
//          BoundStructVarName[2*NpointsInFit]="DUMMY";
          BoundValue[2*NpointsInFit]=2.;
//-----

//      fprintf(MACRO,"ENDATA\n");
//      fclose(MACRO);

//-----------------------  funzioni chiamate direttamente
/*
cout<<"n.  punti nel fit "<<NpointsInFit<<endl;


cout<<"nRows "<<nRows<<endl;
for(int ic =0;ic<nRows; ic++){
   cout<<"n.  Row  "<<ic<<", nameRows "<<nameRows[ic]<<",  typeRows "<<typeRows[ic]<<endl;
}


cout<<"NstructRows, NStructVar "<<NStructRows<<", "<<NStructVar<<endl;
for(int ic =0;ic<NStructVar; ic++){
   cout<<"NRowsInWhichStructVarArePresent  "<<NRowsInWhichStructVarArePresent[ic]<<", nome var. strut. n."<<ic<<"  = "
     <<StructVarName[ic]<<endl;

  for(int jc=0; jc<NRowsInWhichStructVarArePresent[ic];jc++){
   cout<<"n. "<<jc<<"  NameRowsInWhichStructVarArePresent  "<<NameRowsInWhichStructVarArePresent[ic*NStructRows+jc]<<endl;
  }
}


cout<<"n Coefficient "<<NStructVar*NStructRows<<endl;
for(int ic =0;ic<NStructVar*NStructRows; ic++){
   cout<<"n. "<<ic<<",  Coefficient   "<<Coefficients[ic]<<endl;
}
cout<<"n valuesB "<<NpointsInFit*9<<endl;
for(int ic =0;ic<NpointsInFit*9; ic++){
   cout<<"n. "<<ic<<",  valuesB   "<<ValueB[ic]<<endl;
}
cout<<"n ranges "<<nRanges<<endl;
for(int ic =0;ic<nRanges; ic++){
   cout<<"n. "<<ic<<",  RANGES   "<<ValueRanges[ic]<<endl;
}
cout<<"n Bounds "<<nBounds<<endl;
for(int ic =0;ic<nBounds; ic++){
   cout<<"n. "<<ic<<",  Bounds   "<<BoundValue[ic]<<endl;
   cout<<"n. "<<ic<<",  Bound Type   "<<TypeofBound[ic]<<endl;
   cout<<"n. "<<ic<<",  Bound Name   "<<BoundStructVarName[ic]<<endl;
}

*/

      int status= glp_main(
            nRows,nameRows,typeRows, //  ROWS info
            NStructVar, NStructRows, NRowsInWhichStructVarArePresent,  //  COLUMNS info
      StructVarName, NameRowsInWhichStructVarArePresent,  //  COLUMNS info
      Coefficients,  //  COLUMNS info
      ValueB,  // RHS  info
      nRanges, ValueRanges, NameRanges, //  RANGES  info
      nBounds, BoundValue, BoundStructVarName, TypeofBound //  BOUNDS info
//         ,final_values, TIMEOUT  //  timeout is in seconds.
      ,final_values
       );
     if (status != 0) return -100;	// fit failed

/*
printf("from main, final printout con routines chiamate direttamente -------------------------------\n");
printf("      number of structural variables %d\n",NStructVar);
int ica;
for(ica=0;ica<NStructVar;ica++){
    printf("name of structural variable %s and its final value %g\n",
           StructVarName[ica], final_values[ica]);
}
printf("from main, end of final printout  con routines chiamate direttamente -------------------------------\n");
*/
//-----------------------  fine funzioni chiamate direttamente




   if(istampa>=3 && IVOLTE <= nmassimo){
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs",
                                nTracksFoundSoFar,IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE);
   }  else {
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs >& /dev/null",
                                nTracksFoundSoFar, IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE,INTERO);
   }

/*
     system(stringa);
     sprintf(stringa2,"grep -e ' m1  '  -e ' m2  '  -e  ' q1  ' -e ' q2   '  soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
                             nTracksFoundSoFar,IVOLTE,INTERO);
     system(stringa2);


     FILE * RESULT = fopen("temp","r");
     fscanf(RESULT,"%f",&m1_result);
     fscanf(RESULT,"%f",&m2_result);
     fscanf(RESULT,"%f",&q1_result);
     fscanf(RESULT,"%f",&q2_result);
     fclose(RESULT);
*/

     m1_result = final_values[0];
     m2_result = final_values[1];
     q1_result = final_values[2];
     q2_result = final_values[3];

/*
     q_result = q1_result - q2_result;
     m_result = m1_result ;
     A = A1_result - A2_result;
     if( fabs( cose -sine*m_result) > 1.e-12) { 
       *emme = ( m_result*cose  + sine ) / (cose -sine*m_result);
       *qu = q_result/(cose -sine*m_result);
       Status=1;
     } else {
       *emme = m_result*cose  + sine ;
       *qu = q_result;
       Status=99;
     }
*/



//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA


     *qu = q1_result - q2_result;
//     *qu = q1_result;
//     *emme = m1_result ;
     *emme = m1_result-m2_result ;
if(istampa>=3 && IVOLTE <= nmassimo) {

  cout<<"Stampa dal fitter, risultato :   qu, emme non ri-ruotati  "<<*qu<<",  "<<*emme<<endl<<
        "\t\tqu, emme  ri-ruotati  "<<*qu/(cose-*emme*sine)<<",  "<<(*emme*cose+sine)/(cose-*emme*sine)<<endl;
}

    GAMMA[nTracksFoundSoFar] = 0.;
    if( fabs( *qu ) > 1.e-10) {    //  trajectory is a circle in XY space
     ALFA[nTracksFoundSoFar] = *emme/(*qu);
     BETA[nTracksFoundSoFar] = -1./(*qu);
     TypeConf[nTracksFoundSoFar]=true;
//  now take into account the rotation and correct; the only affected quantities are ALFA and BETA
      alfetta = ALFA[nTracksFoundSoFar];
      ALFA[nTracksFoundSoFar] = ALFA[nTracksFoundSoFar]*cose - BETA[nTracksFoundSoFar]*sine;
      BETA[nTracksFoundSoFar] = alfetta*sine + BETA[nTracksFoundSoFar]*cose;
    }  else if(fabs(*emme)> 1.e-10)  {    //  trajectory is a straight line in XY space of equation y= m*x
       //  the rotation first
       angle = atan(*emme) + rotationangle;
       if( fabs(cos(angle)) > 1.e-10 ) {
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = -ALFA[nTracksFoundSoFar]/tan(angle);

       } else {  //  in this case the equation is y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
       }
    }  else {   //  in this case also the equation in XY plane is  y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
    }


// now take into account the displacement and correct
      GAMMA[nTracksFoundSoFar] += (trajectory_vertex[0]*trajectory_vertex[0]+ trajectory_vertex[1]*trajectory_vertex[1]
		-ALFA[nTracksFoundSoFar]*trajectory_vertex[0]-BETA[nTracksFoundSoFar]*trajectory_vertex[1]);
      ALFA[nTracksFoundSoFar] -=  2.*trajectory_vertex[0];
      BETA[nTracksFoundSoFar] -=  2.*trajectory_vertex[1];


//------------------------ end of transformation of the result in terms of ALFA, BETA, GAMMA










//--------   end of taking into account the traslation that was performed and undoing that


// taking into account the rotation that was performed and calculate emme and qu in the normal conformal plane

      if(fabs(cose-*emme*sine)> 1.e-10) {
        *qu=*qu/(cose-*emme*sine);
        *emme=(*emme*cose+sine)/(cose-*emme*sine);
        return 1;
      } else {    //  in this case the equation is   0 = x+*qu .
        if(fabs(sine+*emme*cose) < 1.e-10)  {
  cout<<" From PndSttFitHelixCylinder, situation impossible in principle! Returning -1"
                    <<endl;
           return -1;
        }

        *emme=1.;
        *qu = *qu/(sine+*emme*cose);
        return 99;    //  in this case the equation is   0 = x+*qu .
      }




}




//----------end of function PndSttTrackFinderReal::PndSttFitHelixCylinder









//----------begin of function PndSttTrackFinderReal::PndSttFitHelixCylinder2

      Short_t PndSttTrackFinderReal::PndSttFitHelixCylinder2( UShort_t nHitsinTrack,
//                                                     UShort_t iExclude,
                                                     Double_t auxinfoparalConformal[][5],
                                                     UShort_t  nTracksFoundSoFar,
                                                     Double_t rotationangle,
                                                     Double_t * trajectory_vertex,
                                                     UShort_t NMAX,
                                                     Double_t *ALFA,
                                                     Double_t *BETA,
                                                     Double_t *GAMMA,
                                                     bool *TypeConf
                                                            )
{

     Double_t M = 1.,
              emme, m_result,
              qu, q_result,
              A,
              alfetta,
              angle,
              offsety,
              aux,
              Delta[nmaxHits],
              Ox[nmaxHits],
              Oy[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --

     if( nHitsinTrack < MINIMUMHITSPERTRACK) {
        return -1;
     }

//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
      rotationangle -= PI/18.;

      Double_t cose = cos(rotationangle), sine = sin(rotationangle);
      for(i=0;i<nHitsinTrack; i++){
//       if( i== iExclude)  continue;
       Ox[i] = auxinfoparalConformal[ i ][0] *cose +
               auxinfoparalConformal[ i ][1]*sine;
       Oy[i] = -auxinfoparalConformal[ i ][0] *sine +
               auxinfoparalConformal[ i ][1]*cose;

//cout<<"dal fitter, hit in lista sequenziale, n. "<<i<<",  Ox , Oy ruotati "<<Ox[i]<<",  "<<Oy[i]<<"  drift radius  "
//     <<auxinfoparalConformal[ i ][2]<<"   and  straw radisu  "<<auxinfoparalConformal[ i ][4]<<endl;



//  now traslate toward positive V values to obtain always positive q values
//       offsety = 10./RStrawDetectorMin;
//       Oy[i] += offsety;


//         Delta[i] = auxinfoparalConformal[ i ][4];
         aux = 5.*(auxinfoparalConformal[ i ][4]/StrawRadius)*0.03;
         Delta[i] = 5.*auxinfoparalConformal[ i ][2];
         if( aux> Delta[i])  Delta[i] =aux;

      }

      sprintf(nome,"GeneralParallelHitsConformeTraccia%dEvent%d.mcs",(nTracksFoundSoFar), IVOLTE);
      MACRO = fopen(nome,"w");
      fprintf(MACRO,"NAME    FIT\n");
//-----------------  write the ROWS  section

      fprintf(MACRO,"ROWS\n");
      fprintf(MACRO," N OBJECT\n");
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
           fprintf(MACRO," L Ap%d\n L Bp%d\n L Cp%d\n L Dp%d\n",i,i,i,i);
           fprintf(MACRO," L Am%d\n L Bm%d\n L Cm%d\n L Dm%d\n E LAMBDA%d\n",i,i,i,i,i);
      }

//-----------------  write the COLUMNS  section

      fprintf(MACRO,"COLUMNS\n");






//  Column variable  A1
//      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
//       ii++;
//          fprintf(MACRO,"  A1 Ap%d  %g  Am%d  %g\n  A1 Bp%d  %g   Bm%d  %g\n",
//                                  i,Ox[i]*Ox[i],i,Ox[i]*Ox[i],i,-Ox[i]*Ox[i],i,-Ox[i]*Ox[i]);
//      }
//  Column variable  A2
//      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
//       ii++;
//          fprintf(MACRO,"  A2 Ap%d  %g  Am%d  %g\n  A2 Bp%d  %g   Bm%d  %g\n",
//                                  i,-Ox[i]*Ox[i],i,-Ox[i]*Ox[i],i,Ox[i]*Ox[i],i,Ox[i]*Ox[i]);
//      }











//  Column variable  m1
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  m1 Ap%d  %g  Am%d  %g\n  m1 Bp%d  %g   Bm%d  %g\n",
                                  i,Ox[i],i,Ox[i],i,-Ox[i],i,-Ox[i]);
      }

//  Column variable  m2
//      for(i=0; i< nHitsinTrack && i<NMAX ; i++) {
//          fprintf(MACRO,"  m2 Ap%d  %g  Am%d  %g\n  m2 Bp%d  %g   Bm%d  %g\n",
//                                  i,-Ox[i],i,-Ox[i],i,Ox[i],i,Ox[i]);
//      }

//  Column variable  q1
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  q1 Ap%d   1.  Am%d   1.\n  q1 Bp%d  -1.  Bm%d  -1.\n",
                                  i,i,i,i);
      }

//  Column variable  q2
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  q2 Ap%d   -1.  Am%d   -1.\n  q2 Bp%d   1.   Bm%d   1.\n",
                                  i,i,i,i);
      }

//  Column variable  lambdap(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  lamp%d  Ap%d  %g  Bp%d  %g\n  lamp%d  Cp%d  %g  Dp%d   %g\n  lamp%d  LAMBDA%d  1.\n",
                                                i,i,-M,i,-M, i , i,-M, i, M, i,i);
      }
//  Column variable  lambdam(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  lamm%d  Am%d  %g  Bm%d  %g\n  lamm%d  Cm%d  %g  Dm%d %g\n  lamm%d  LAMBDA%d  1.\n",
                                                i,i,-M,i,-M, i,i , -M, i, M, i,i);
      }
//  Column variable  sigmap(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;

          fprintf(MACRO,"  sigmap%d  OBJECT  %g  Ap%d  -1.\n  sigmap%d  Bp%d    -1. Cp%d  1.\n  sigmap%d  Dp%d -1.\n",
                                                i,1./Delta[i],i,i,i,i,i,i);
      }
//  Column variable  sigmam(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  sigmam%d  OBJECT %g  Am%d  -1.\n  sigmam%d  Bm%d   -1. Cm%d   1.\n  sigmam%d  Dm%d  -1.\n",
                                                i,1./Delta[i],i,i,i,i,i,i);
      }

//  Column variable  DUMMY
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
        fprintf(MACRO,"  DUMMY     Ap%d  1.      Am%d       1.\n  DUMMY   Bp%d   1.    Bm%d   1.\n  DUMMY    Cp%d   1.   Cm%d   1\n",
                                                i,i,i,i,i,i);
        fprintf(MACRO,"  DUMMY     Dp%d  1.      Dm%d       1.\n",
                                                i,i);
      }
//-----------------  write the RHS  section

      fprintf(MACRO,"RHS\n");
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  BOUND  Ap%d  %g  Bp%d  %g\n  BOUND  Cp%d  %g  Dp%d  %g\n",
              i, Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
                -Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);

          fprintf(MACRO,"  BOUND  Am%d  %g  Bm%d  %g\n  BOUND  Cm%d  %g  Dm%d %g\n",
              i, Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
                -Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);
          fprintf(MACRO,"  BOUND  LAMBDA%d   1.\n",i);
      }


//-----------------  write the RANGES  section

/*
      fprintf(MACRO,"RANGES\n");
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  RANGE  LAMBDA%d  1.\n",i);
      }
*/

//-----------------  write the BOUNDS  section

      fprintf(MACRO,"BOUNDS\n");
//      fprintf(MACRO," FR  Bounds  m\n FR  Bounds  q\n");

      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO," BV  Bounds  lamp%d\n",  i);
      }

      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO," BV  Bounds  lamm%d\n", i);
      }

          fprintf(MACRO," FX  Bounds  DUMMY  %g\n",2.*M);

//-----

      fprintf(MACRO,"ENDATA\n");
      fclose(MACRO);


   if(istampa>=3 && IVOLTE <= nmassimo){
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs",
                                nTracksFoundSoFar,IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE);
   }  else {
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs >& /dev/null",
                                nTracksFoundSoFar, IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE,INTERO);
   }
     system(stringa);
//     sprintf(stringa2,"grep -e ' m1  '   -e  ' q1  ' -e ' q2   ' -e ' A1 ' -e ' A2 ' soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
//                             (nTracksFoundSoFar),IVOLTE,INTERO);
     sprintf(stringa2,"grep -e ' m1  '   -e  ' q1  ' -e ' q2   '  soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
                             nTracksFoundSoFar,IVOLTE,INTERO);
//     sprintf(stringa2,"grep -e ' m1  '   -e  ' q1  '   soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
//                             nTracksFoundSoFar,IVOLTE,INTERO);
     system(stringa2);


     FILE * RESULT = fopen("temp","r");
//     fscanf(RESULT,"%f",&A1_result);
//     fscanf(RESULT,"%f",&A2_result);
     fscanf(RESULT,"%f",&m1_result);
//     fscanf(RESULT,"%f",&m2_result);
     fscanf(RESULT,"%f",&q1_result);
     fscanf(RESULT,"%f",&q2_result);
     fclose(RESULT);
//     system ("rm -f temp");
//     system ("rm -f soluz*    ");
//     system("rm -f GeneralParallelHitsConformeTraccia*");




/*
     q_result = q1_result - q2_result;
     m_result = m1_result ;
     A = A1_result - A2_result;
     if( fabs( cose -sine*m_result) > 1.e-12) { 
       emme = ( m_result*cose  + sine ) / (cose -sine*m_result);
       qu = q_result/(cose -sine*m_result);
       Status=1;
     } else {
       emme = m_result*cose  + sine ;
       qu = q_result;
       Status=99;
     }
*/



//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA


     qu = q1_result - q2_result;
//     qu = q1_result;
     emme = m1_result ;
//if(istampa)   cout<<"Stampa dal fitter, prima della correzione displacement   qu, emme  "<<qu<<",  "<<emme<<endl;
//  cancel the effect of the last Y displacement
//     qu -= offsety;
if(istampa>=3 && IVOLTE <= nmassimo) {

  cout<<"Stampa dal fitter, risultato :   qu, emme non ri-ruotati  "<<qu<<",  "<<emme<<endl<<
        "                                 qu, emme  ri-ruotati  "<<qu/(cose-emme*sine)<<",  "<<(emme*cose+sine)/(cose-emme*sine)<<endl;
}

    GAMMA[nTracksFoundSoFar] = 0.;
    if( fabs( qu ) > 1.e-10) {    //  trajectory is a circle in XY space
     ALFA[nTracksFoundSoFar] = emme/qu;
     BETA[nTracksFoundSoFar] = -1./qu;
     TypeConf[nTracksFoundSoFar]=true;
//  now take into account the rotation and correct; the only affected quantities are ALFA and BETA
      alfetta = ALFA[nTracksFoundSoFar];
      ALFA[nTracksFoundSoFar] = ALFA[nTracksFoundSoFar]*cose - BETA[nTracksFoundSoFar]*sine;
      BETA[nTracksFoundSoFar] = alfetta*sine + BETA[nTracksFoundSoFar]*cose;
    }  else if(fabs(emme)> 1.e-10)  {    //  trajectory is a straight line in XY space of equatio y= m*x
       //  the rotation first
       angle = atan(emme) + rotationangle;
       if( fabs(cos(angle)) > 1.e-10 ) {
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = -ALFA[nTracksFoundSoFar]/tan(angle);

       } else {  //  in this case the equation is y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
       }
    }  else {   //  in this case also the equation in XY plane is  y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
    }


// now take into account the displacement and correct
      GAMMA[nTracksFoundSoFar] += (trajectory_vertex[0]*trajectory_vertex[0]+ trajectory_vertex[1]*trajectory_vertex[1]
                                  -ALFA[nTracksFoundSoFar]*trajectory_vertex[0]-BETA[nTracksFoundSoFar]*trajectory_vertex[1]);
      ALFA[nTracksFoundSoFar] -=  2.*trajectory_vertex[0];
      BETA[nTracksFoundSoFar] -=  2.*trajectory_vertex[1];


//------------------------ end of transformation of the result in terms of ALFA, BETA, GAMMA










// taking into account the traslation that was performed and undoing that
/*
      if( Status == 99) {      // in this case in the conformal space equation is m*X + q  = 0
         GAMMA[nTracksFoundSoFar] = trajectory_vertex[0]*trajectory_vertex[0]+trajectory_vertex[1]*trajectory_vertex[1]
                 -trajectory_vertex[0]*emme/qu;
           TypeConf[nTracksFoundSoFar]=true;
           ALFA[nTracksFoundSoFar]=  emme/qu - 2.*trajectory_vertex[0] ;
           BETA[nTracksFoundSoFar]= - 2.*trajectory_vertex[1];

      }  else if ( fabs(qu) > 1.e-10 ) {
         GAMMA[nTracksFoundSoFar]= trajectory_vertex[0]*trajectory_vertex[0]+trajectory_vertex[1]*trajectory_vertex[1]
                 -trajectory_vertex[0]*emme/qu + trajectory_vertex[1]/qu;
           TypeConf[nTracksFoundSoFar]=true;
           ALFA[nTracksFoundSoFar]= ( emme/qu - 2.*trajectory_vertex[0] );
           BETA[nTracksFoundSoFar]= (-1./qu - 2.*trajectory_vertex[1]);

      } else {     //   this is the case when q=0
         GAMMA[nTracksFoundSoFar] = -trajectory_vertex[0]*emme + trajectory_vertex[1];
           TypeConf[nTracksFoundSoFar]=false;
           ALFA[nTracksFoundSoFar]= emme;
           BETA[nTracksFoundSoFar]= -1.;
           GAMMA[nTracksFoundSoFar]= 0.;

      }

*/
//--------   end of taking into account the traslation that was performed and undoing that







      return 1;

}




//----------end of function PndSttTrackFinderReal::PndSttFitHelixCylinder2














//----------begin of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater

  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater(
		   bool ExclusionList[nmaxHits],
                   Double_t m,
                   Double_t q,
                   Short_t Status,
                   UShort_t nHitsinTrack,
                   UShort_t *ListHitsinTrack,
                   Int_t NhitsParallel,
                   Double_t Ox,
                   Double_t Oy,
                   Double_t R,
                   Double_t info[][7],
                   Double_t infoparalConformal[][5],
                   UShort_t *RConformalIndex,
                   UShort_t *FiConformalIndex,
                   UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                   UShort_t HitsinBoxConformal[][nRdivConformal][nFidivConformal],
                   UShort_t *auxListHitsinTrack
                                                     )
{
  bool passamin,passamax,
       Unselected[nmaxHits];

  Short_t i, i2, j, k, l,  l2, l3, itemp, kstart, kend,
          iFi0,FFimin, FFimax;
  UShort_t Nextra=8,
           nFi,
           Fi,
           nR,
           nAssociatedHits,
           nHit_original;
  Double_t maxFi,
           minFi,
           dist,
           xx,
           yy,
           aaa,
           angle,
           r,
           erre1,
           erre2,
           Rin,
           Rout,
           Fi0,
           ddd,
           fi1,
           fi2,
           dx,
           dy,
           distance,
           NTIMES=1.5;   //   number of Straw radia allowed in association

  nAssociatedHits=0;
  for(i=0; i<NhitsParallel;i++){
   Unselected[i]= true;
  }

//   find the range in Fi spanned  by the candidate track

  FFimin = 10000;
  FFimax = 0;
  for(j=0; j<nHitsinTrack; j++){
    i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];


    if( FiConformalIndex[i] <  FFimin ) FFimin = FiConformalIndex[i];
    if( FiConformalIndex[i] >  FFimax ) FFimax = FiConformalIndex[i];
  }


  if( FFimax > 3.*nFidivConformal/4. && FFimin < nFidivConformal/4.) {
     FFimin = 10000;
     FFimax =  0;
     for(j=0; j<nHitsinTrack; j++){
       i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
       Fi = FiConformalIndex[i];
       if( Fi < nFidivConformal/4. ) Fi = FiConformalIndex[i]+nFidivConformal;
       if( Fi <  FFimin ) FFimin = Fi;
       if( Fi >  FFimax ) FFimax = Fi;
     }
  }


//  finding the boundaries in the Conformal plane. The basic assumption is that the range
// in Fi is much less that 180 degrees.
  
  FFimin -= (Short_t) nFidivConformal/Nextra;
  FFimax +=  (Short_t) nFidivConformal/Nextra;
if( FFimax - FFimin > nFidivConformal/2 ) {
    cout<<"something fishy is going on in PndSttTrkAssociatedParallelHitsToHelixQuater!"
      <<"Range in Fi (rad) is  "<<(FFimax - FFimin)*2.*PI/nFidivConformal<<endl;
    return 0;
}



//   use the equation of a line in polar coordinates
 
  if( Status ==99) {   //  case in which   0 = x + q

    if(fabs(q) > 1.e-10 ) {
      passamax=false;
      passamin=false;
      for(itemp=FFimin; itemp<=FFimax;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        angle = (i+0.5)*2.*PI/nFidivConformal;
        aaa = cos(angle);
        if( fabs(cos(angle)) <1.e-10)  continue;
        r = -q/aaa;
        if(r< radiaConf[0] || r>= 1./RStrawDetectorMin)  continue;
        for(j=nRdivConformalEffective-1; j>=0;j--){
          if( r>= radiaConf[j] ){
           nR = j;
           break;
          }
        }


        for(l=-DELTAnR; l<DELTAnR+1;l++){
          l2 = nR+l;
          if(  l2<0 || l2 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l2][i];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[k][l2][i]  ][3];
		if( !ExclusionList[ nHit_original ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
//cout<<"nuov, R "<<R<<",  distance  "<<distance<<endl;
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[k][l2][i]  ][0];
                dist = fabs( xx +q );
                if(  PndSttAcceptHitsConformal(  dist,
			infoparalConformal[  HitsinBoxConformal[k][l2][i]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l2][i]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l2][i];
                    nAssociatedHits++; 
                }
              }	//  end of  for( k=0;k<nBoxConformal[l2][i];k++)
        }   //   end of for(l=-DELTAnR; l<DELTAnR+1;l++)

        // ------- special cases
           if((nR == nRdivConformalEffective-1 && passamin && ! passamax) ||  (nR==0 && passamax && !passamin)  ) {   //  do the last two Fi columns
            if(nR == nRdivConformalEffective-1)  passamax=true;
            if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i+l2;
             if(i2>=nFidivConformal) i2 -=  nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][3];
		if( !ExclusionList[ nHit_original ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l3][i2];
                    nAssociatedHits++; 
                }
              }	//  end of   for( k=0;k<nBoxConformal[l3][i2];k++)
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
            return  nAssociatedHits;
           } else if ((nR == nRdivConformalEffective-1 && ! passamin && !passamax) || (nR==0 && !passamax && !passamin)){
             if(nR == nRdivConformalEffective-1)  passamax=true;
             if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i-l2;
             if(i2<nFidivConformal) i2 += nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][3];
		if( !ExclusionList[ nHit_original ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l3][i2]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l3][i2];
                    nAssociatedHits++; 
                }
              }	//  end of  for( k=0;k<nBoxConformal[l3][i2];k++)
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
           }    //   end of if((nR == nRdivConformalEffective-1 && passamin) ||  (nR==0 && passamax)  )



      }   //  end of     for(itemp=Fimin; itemp<=FFimax;itemp++)


    } else {  //  q=0 --> x=0



      if( FFimax > nRdivConformal/4 && Fimin < nRdivConformal/4 ) {
        iFi0 =  (Short_t)  (nRdivConformal/4 );
      } else if ( FFimax > 3*nRdivConformal/4 && Fimin < 3*nRdivConformal/4 ){
        iFi0 =  (Short_t)  (3*nRdivConformal/4 );
      }  else {
                cout <<"From PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater  :"
                      <<"  inconsistency, 0 associated hits to this track candidate\n";
        return 0;
     }

      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[k][l][i]  ][3];
		if( !ExclusionList[ nHit_original ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) >NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[k][l][i]  ][0];
                dist = fabs( xx  );

                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[k][l][i]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l][i]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l][i];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }  //  end of for(l=0; l<nRdivConformalEffective;l++)
      }   //  end of for(itemp=iFi0-5; itemp<=iFi0+5;itemp++)




      }    //   end  of if(fabs(q) > 1.e-10 )


  }  else if( fabs(q)> 1.e-10) {   //   second part of    if( Status ==99),  in this case y = m*x +q


	Fi0 = atan(m);	// Fi0 belongs to (-PI/2, PI/2] .
	aaa = atan2(q, -m*q);
	if(Fi0<0.)  {
	 Fi0 += PI;
	 if (Fi0 <0. ) Fi0 =0.;// this is between 0. and PI.
	 if (Fi0 >PI ) Fi0 =PI;// this is between 0. and PI.
	};
	ddd= fabs(q)/sqrt(1.+m*m);


        for(itemp=FFimin; itemp<=FFimax;itemp++){
         i=itemp;
         if( i< 0 ) {
            i += nFidivConformal;
         } else if (i>=nFidivConformal){
            i -=  nFidivConformal*( i/nFidivConformal );
         }

	// erre1 is the distance from origin of point of intersection of the straight
	// line of equation  y= m*x+q  with  line of equation  y = x*tan(fi1);
	// when erre1 is < 0 it means the intersection is on the opposite side of the
	// versor defined by  [cos(fi1); sin(fi1)].
	// Here we are working in the conformal plane U,V.

         fi1 = i*2.*(PI/nFidivConformal);
         if( fabs(sin(fi1)-m*cos(fi1))>1.e-10) {
                 erre1 = q/(sin(fi1)-m*cos(fi1));
         } else {
                 erre1 = 99999999999.;
         }

         fi2 = (i+1)*2.*(PI/nFidivConformal);
         if( fabs(sin(fi2)-m*cos(fi2))>1.e-10) {
                 erre2 = q/(sin(fi2)-m*cos(fi2));
         } else {
                 erre2 = 99999999999.;
         }


         for(j=0; j<nRdivConformal; j++){
              Rin = radiaConf[j];
              if(j!=nRdivConformal-1) {
                 Rout =  radiaConf[j+1];
              }  else {
                 Rout = 1./RStrawDetectorMin;
              }

//  note that the following algorithm works also for negative erre1  and   erre2


              if(erre1<-1.e-10 ){
                if(erre2< 0. || erre2 > Rout ){
                     continue;
                }
              } else if(fabs(erre1) < 1.e-10){
                if( Fi0 > fi2 || Fi0 < fi1){
		  continue;
		}
              } else if ( erre1<Rin) {
                if( erre2< Rin &&  erre2> 0. ) {
		 continue;
		}
              }   else if (erre1> Rout  &&  erre2 > Rout && !( fi1<= aaa && aaa<=fi2 && ddd<=Rout )
                ) {
                   continue;
             }

              for(l=itemp-2; l<=itemp+2; l++){
                if( l< 0 ) {
                  l2 = l+nFidivConformal;
                } else if (l>=nFidivConformal){
                  l2 = l- nFidivConformal*( l/nFidivConformal );
               } else {
                 l2 = l;
               }
                if( j-1<0) {
                  kstart=0;
                }  else {
                  kstart = j-1;
                }
                if ( j+1 >=  nRdivConformal ) {
                  kend = nRdivConformal;
                } else {
                  kend = j+2;
                }

                for(k=kstart;k<kend;k++){

                 for( l3=0;l3<nBoxConformal[k][l2];l3++){
                  if( ! Unselected[HitsinBoxConformal[l3][k][l2] ] )  continue;
                   nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[l3][k][l2]  ][3];
		   if( !ExclusionList[ nHit_original ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit
                   dx = -Ox+info[ nHit_original ][0];
                   dy = -Oy+info[ nHit_original ][1];
                   distance = sqrt(dx*dx+dy*dy);
                   if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                   xx=infoparalConformal[  HitsinBoxConformal[l3][k][l2]  ][0];
                   yy=infoparalConformal[  HitsinBoxConformal[l3][k][l2]  ][1];
                   dist = fabs( -yy+ m*xx +q )/sqrt(m*m+1.);
                   if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][k][l2]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][k][l2]  ][4]
                                                      ) )  {

                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][k][l2];
                    Unselected[HitsinBoxConformal[l3][k][l2]]= false;
                    nAssociatedHits++;
                   }

                 }   //   end of  for( l3=0;l3<nBoxConformal[k][l2];l3++)
                }   //   end of  for(k=kstart;k<kend;k++)
              }     //   end of  for(l=itemp-1; l<itemp+2; l++)

         }   //  end of for(j=0; j<nRdivConformal; j++)

        }   //   end of    for(itemp=FFimin; itemp<=FFimax;itemp++)




  } else {  //  case in which    y= m*x ,  m can be zero    ,  third part of if( Status ==99)

      iFi0 =  (Short_t)  (atan(m)*nRdivConformal/(2.*PI) );
      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
         i=itemp;
         if( i< 0 ) {
          i += nFidivConformal;
         } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//          i -= nFidivConformal;
         }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[k][l][i]  ][3];
		if( !ExclusionList[ nHit_original ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[k][l][i]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[k][l][i]  ][1];
                dist = fabs( m*xx-yy  )/sqrt( m*m+1.);
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[k][l][i]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l][i]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l][i];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }
      }   //  end of for(itemp=FFimin; itemp<=FFimax;itemp++)





  }   //   end of if ( Status ==99)


if(istampa>=3) {
  cout<<"from PndSttTrkAssociatedParallelHitsToHelixQuater, before exiting; nAssociatedHits = "
   <<nAssociatedHits<<endl;
}



 return nAssociatedHits;

}



//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater




























//----------begin of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix5

  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix5(
		bool ExclusionList[nmaxHits],
		Int_t NhitsParallel,
		Double_t Ox,
		Double_t Oy,
		Double_t R,
		Double_t info[][7],
		Double_t Fi_low,
		Double_t Fi_up,
		UShort_t *auxListHitsinTrack
			)
{

  Short_t i;

  UShort_t nAssociatedHits;

  Double_t angle,
           dx,
           dy,
           distance,
           NTIMES=5.;   //   number of Straw radia allowed in association.

  nAssociatedHits=0;
//   find the Hits belonging to this Track.



  for(i=0; i<NhitsParallel;i++){
	if( !ExclusionList[ infoparal[i] ] ) continue;
// check if the hit position is near the circle of the Helix found by the fit





	dx = -Ox+info[ infoparal[i] ][0];
	dy = -Oy+info[ infoparal[i] ][1];
	angle=atan2(dy,dx);
	if(angle<0.) angle += 2.*PI;
	if(angle<0.) angle =0.;
	distance = sqrt(dx*dx+dy*dy);
	if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;
	if(angle<Fi_low) angle += 2.*PI;
	if(angle>Fi_up) continue;
	auxListHitsinTrack[nAssociatedHits]= i;
	nAssociatedHits++; 
  } // end for(i=0; i<NhitsParallel;i++)

 return nAssociatedHits;

}



//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix5

























//----------begin of function PndSttTrackFinderReal::PndSttAcceptHitsConformal

bool  PndSttTrackFinderReal::PndSttAcceptHitsConformal(  Double_t  distance,
                                                         Double_t  DriftConfR, //drift radius in conformal space
                                                         Double_t  StrawConfR  // straw radius in conformal space
                                                      )
{
//if( IVOLTE==2 && ITRACCIA ==8) cout <<" fabs(distance-DriftConfR)  "<<fabs(distance-DriftConfR)<<
//       ",   2.*StrawConfR  "<< 2.*StrawConfR<<endl;
     if(  fabs(distance-DriftConfR)  <   2.*StrawConfR )   return true;
     return false;


}




//----------end of function PndSttTrackFinderReal::PndSttAcceptHitsConformal

























//----------begin of function PndSttTrackFinderReal::AssociateSkewHitsToXYTrack

  UShort_t PndSttTrackFinderReal::AssociateSkewHitsToXYTrack(
                   bool *ExclusionListSkew,
                   Double_t Ox,
                   Double_t Oy,
                   Double_t R,
                   Double_t info[][7],
                   Double_t inclination[][3],
                   Double_t Fi_low_limit,
                   Double_t Fi_up_limit,
//                   Double_t Fi_allowedforskew_low,
//                   Double_t Fi_allowedforskew_up,
                   Short_t  Charge,
                   Double_t Fi_initial_helix_referenceframe,
                   Double_t Fi_final_helix_referenceframe,
                   UShort_t SkewList[nmaxHits][2], // output,  list of selected skew hits (in skew numbering)
                   Double_t *S,       //  output,  S coordinate of selected Skew hit
                   Double_t *Z,       //  output,  Z coordinate of selected Skew hit
                   Double_t *ZDrift,   //  output,  drift distance IN Z DIRECTION only, of selected Skew hit
                   Double_t *ZErrorafterTilt   //  output,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                                                     )
 {



    Int_t i, j, i1, ii, iii, NAssociated, Kincl, nlow, nup, STATUS, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];


//   calculate the Fi range allowed to the skew hits, with Fi calculated in the TRACK CYLINDER REFERENCE FRAME.

//      Smin=zmin = 1.e10;
//      Smax=zmax = -zmin;
      NAssociated=0;

       for( iii=0; iii< NSkewhits; iii++) {
         i = infoskew[iii];
         if( !ExclusionListSkew[i]) continue;


         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;


       for( ii=0; ii<2; ii++){

        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;

        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;

        if( distance >= info[i][4] + Aellipsis1 ) continue;

// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

//        if(
//             fabs(POINTS1[j+2]-info[i][2]) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
//             distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
//          ) {
// if( istampa)  cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
//     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
//           continue;
//          }
//--------------------------


        S[NAssociated] = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( S[NAssociated] < 0.) S[NAssociated] += 2.*PI;

//  check if the S of this intersection is compatible with information coming from the parallel fit of this track
//        Double_t Sprime = atan2(POINTS1[j+1], POINTS1[j]) ;
//        if( Sprime < 0.) Sprime += 2.*PI;

//        if(  Sprime < Fi_low_limit) {
//           if(  Sprime+2.*PI > Fi_up_limit)  continue;
//        }  else {
//           if(  Sprime > Fi_up_limit)  continue;
//        }


        if(  S[NAssociated] < Fi_low_limit) {
           if(  S[NAssociated]+2.*PI > Fi_up_limit)  continue;
        }  else if(  S[NAssociated] > Fi_up_limit) {
	   if(  S[NAssociated]- 2.*PI < Fi_low_limit)  continue;
        }



//  second check, to see if this hits are in the allowed Fi range in the Helix reference frame
/*
        if ( S[NAssociated] <  Fi_allowedforskew_low) {
              if (S[NAssociated] + 2.*PI >  Fi_allowedforskew_up)  continue;
        } else {
              if (S[NAssociated] >  Fi_allowedforskew_up)  continue;
        }
*/

//---------------------------   end check


        Z[NAssociated] = POINTS1[j+2];
        ZDrift[NAssociated] = Aellipsis1*Tiltdirection1[0];
        ZErrorafterTilt[NAssociated] = StrawDriftError*aaa*Tiltdirection1[0]/LL;
        SkewList[NAssociated][0] = iii;  // n. skew hit in skew hit numbering
        SkewList[NAssociated][1] = ii;  //  solution 0 or solution 1 were accepted


// check if this skew hit doesn't "push out"  the most external parallel hit
// (see Gianluigi's logbook on page 251)

        Double_t Zh1 = Z[NAssociated] - ZDrift[NAssociated];
        Double_t Zh2 = Z[NAssociated] + ZDrift[NAssociated];
        Double_t Sh1 = S[NAssociated] - Aellipsis1*Tiltdirection1[1];
        Double_t Sh2 = S[NAssociated] + Aellipsis1*Tiltdirection1[1];
        Double_t Zlast1 = (Fi_final_helix_referenceframe-Fi_initial_helix_referenceframe)*Zh1
                                  /(Sh1-Fi_initial_helix_referenceframe);
        Double_t Zlast2 = (Fi_final_helix_referenceframe-Fi_initial_helix_referenceframe)*Zh2
                                  /(Sh2-Fi_initial_helix_referenceframe);




        if( fabs(Zlast1 - ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT
                                  &&
            fabs(Zlast2 - ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT
           )   continue;


        NAssociated++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   for( iii=0; iii< NSkewhits; iii++)



  return NAssociated;



 }

//----------end of function PndSttTrackFinderReal::AssociateSkewHitsToXYTrack











//----------begin of function PndSttTrackFinderReal::AssociateBetterAfterFitSkewHitsToXYTrack

  UShort_t PndSttTrackFinderReal::AssociateBetterAfterFitSkewHitsToXYTrack(
                   UShort_t TemporarynSkewHitsinTrack,  //  input
                   UShort_t SkewList[nmaxHits][2], // input,  list of selected skew hits (in skew numbering)
                   Double_t *S,       //  input,  S coordinate of selected Skew hit
                   Double_t *Z,       //  input,  Z coordinate of selected Skew hit
                   Double_t *ZDrift,  //  input,  drift distance IN Z DIRECTION only, of selected Skew hit
                   Double_t *ZErrorafterTilt,   //  input,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                   Double_t KAPPA,    // input, KAPPA result of fit
                   Double_t FI0,    // input, FI0 result of fit
                   UShort_t *tempore,  //  output result, associated skew hits
                   Double_t *temporeS,  //  output, associated skew hit  S
                   Double_t *temporeZ,  //  output, associated skew hits Z
                   Double_t *temporeZDrift,  //  output, associated skew hit Z drift
                   Double_t *temporeZErrorafterTilt,  //  output, associated skew hits Z error after tilt
                   Int_t  *STATUS   // output
                                                     )
 {



    UShort_t NAssociated;
    Short_t  sign;
    Int_t i, j, i1, ii, iii,  Kincl, nlow, nup;

    Double_t bbb,
             tempZ[2],
             zmin, zmax, deltaz,
		zdist[2],
		zdist1,
		zdist2;

    Double_t allowed_distance = 4.*StrawRadius/sin(SKEWinclination_DEGREES*PI/180.);


    if(fabs(KAPPA)<1.e-20) {
      *STATUS=-1;
      return 0;
    }


    NAssociated=0;

    if(KAPPA>0) {
     zmin = -FI0/KAPPA;
     zmax = (2.*PI-FI0)/KAPPA;
    }  else {
     zmax = -FI0/KAPPA;
     zmin = (2.*PI-FI0)/KAPPA;
    }
    deltaz = zmax-zmin;

     for(i=0; i<TemporarynSkewHitsinTrack; i++){
       bbb=(S[i]-FI0)/KAPPA;
      for(sign=0;sign<=1; sign ++){
       tempZ[sign]=Z[i]+(2*sign-1)*ZDrift[i];
       if( tempZ[sign] > zmax ){
         tempZ[sign]=fmod( tempZ[sign]-zmax, deltaz) + zmin;
       } else if (tempZ[sign]<zmin){
         tempZ[sign]=fmod( tempZ[sign]-zmin, deltaz) + zmax;
       }

	zdist1 = fabs( bbb - tempZ[sign]);
	zdist2 = deltaz- zdist1;
	if(zdist2<0.) zdist2 = 0.;  // protect against rounding errors.
	zdist[sign] = zdist1 < zdist2 ? zdist1 : zdist2;
      }  //  end of for(sign=0;sign<=1; sign++)


	zdist1 = zdist[0] < zdist[1] ? zdist[0] : zdist[1];


	if(  zdist1 < allowed_distance ){

//       if(  zdist < 4.*ZErrorafterTilt[i] ){

         tempore[NAssociated]=SkewList[ i ][0];
         temporeS[NAssociated]=S[i];
         temporeZ[NAssociated]=Z[i];
         temporeZDrift[NAssociated]=ZDrift[i];
         temporeZErrorafterTilt[NAssociated]=ZErrorafterTilt[i];
         NAssociated++;
       }


     }   //  end of for(i=0; i<TemporarynSkewHitsinTrack; i++)


     *STATUS=0;

     return NAssociated;



 }

//----------end of function PndSttTrackFinderReal::AssociateBetterAfterFitSkewHitsToXYTrack











//----------begin of function PndSttTrackFinderReal::PndSttFitSZspace


     Short_t PndSttTrackFinderReal::PndSttFitSZspace(
                                                     UShort_t nHitsinTrack,
                                                     Double_t *S,
                                                     Double_t *Z,
                                                     Double_t *DriftRadius,
                                                     Double_t rotationangle,
                                                     UShort_t NMAX,
                                                     Double_t *emme,
                                                     Double_t *qu
                                                            )
{







    //   definition of variables for the glpsol  solver
   //    ROWS (for read_rows  function)
   //
   UShort_t  NpointsInFit = nHitsinTrack-NMAX <0 ?  nHitsinTrack :  NMAX;
   int    nRows= NpointsInFit*9 +1;
   int typeRows[nRows];
   char * nameRows[nRows];
   char  auxnameRows[nRows][20];
//-------  end ROWS information
//--------begin COLUMNS information
      int  NStructVar=5+NpointsInFit*4;  //  number of  structural variables
      int  NStructRows = 8*NpointsInFit ;  //  maximum number of ROWS in which a structural variable can be found
      double final_values[NStructVar];
      int  NRowsInWhichStructVarArePresent[NStructVar];
      char *StructVarName[NStructVar];
      char auxStructVarName[NStructVar][20];
      char *NameRowsInWhichStructVarArePresent[NStructVar*NStructRows];
      char aux[NStructVar*NStructRows][20];
//      double Coefficients[NStructVar][NStructRows];
      double Coefficients[NStructVar*NStructRows];
//--------end COLUMNS information
//--------begin RHS information
      double ValueB[9*NpointsInFit];
//--------end RHS information
//--------begin RANGES information
      int nRanges = NpointsInFit;
      double ValueRanges[nRanges];
      char *NameRanges[nRanges];
      char auxNameRanges[nRanges][20];
//--------end RANGES information
//--------start BOUNDS information
      int nBounds=2*NpointsInFit+1;
      double BoundValue[nBounds];
      char *BoundStructVarName[nBounds];
      char auxBoundStructVarName[nBounds][20];
      char *TypeofBound[nBounds];
      char auxTypeofBound[nBounds][20];
//--------end BOUNDS information


//----------------------------------------------------







     Double_t M = 50.,
              m_result,
              q_result,
              A,
              alfetta,
              angle,
              offsety,
              Ox[nmaxHits],
              Oy[nmaxHits],
              Delta[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

//     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --

     if( nHitsinTrack < MINIMUMHITSPERTRACK) {
        return -1;
     }


//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
//      rotationangle -= PI/18.;

      Double_t cose = cos(rotationangle), sine = sin(rotationangle);
      for(i=0;i<nHitsinTrack; i++){
       Ox[i] = Z[ i ] *cose +
               S[ i ]*sine;
       Oy[i] = -Z[ i ] *sine +
               S[ i ]*cose;






         Delta[i] = 2.;

      }

//-----------------  write the ROWS  section



//--------
      sprintf(&(auxnameRows[0][0]),"OBJECT",i);
      nameRows[0]=&auxnameRows[0][0];
      typeRows[0]=GLP_FR;
      for(i=0 ; i< NpointsInFit ; i++) {
       ii=9*i;
       typeRows[1+ii]=GLP_UP;typeRows[2+ii]=GLP_UP;typeRows[3+ii]=GLP_UP;typeRows[4+ii]=GLP_UP;
       typeRows[5+ii]=GLP_UP;typeRows[6+ii]=GLP_UP;typeRows[7+ii]=GLP_UP;typeRows[8+ii]=GLP_UP;
       typeRows[9+ii]=GLP_LO;

       sprintf(&(auxnameRows[1+ii][0]),"Ap%d",i);  nameRows[1+ii]=&auxnameRows[1+ii][0];
       sprintf(&(auxnameRows[2+ii][0]),"Bp%d",i);  nameRows[2+ii]=&auxnameRows[2+ii][0];
       sprintf(&(auxnameRows[3+ii][0]),"Cp%d",i);  nameRows[3+ii]=&auxnameRows[3+ii][0];
       sprintf(&(auxnameRows[4+ii][0]),"Dp%d",i);  nameRows[4+ii]=&auxnameRows[4+ii][0];
       sprintf(&(auxnameRows[5+ii][0]),"Am%d",i);  nameRows[5+ii]=&auxnameRows[5+ii][0];
       sprintf(&(auxnameRows[6+ii][0]),"Bm%d",i);  nameRows[6+ii]=&auxnameRows[6+ii][0];
       sprintf(&(auxnameRows[7+ii][0]),"Cm%d",i);  nameRows[7+ii]=&auxnameRows[7+ii][0];
       sprintf(&(auxnameRows[8+ii][0]),"Dm%d",i);  nameRows[8+ii]=&auxnameRows[8+ii][0];
       sprintf(&(auxnameRows[9+ii][0]),"LAMBDA%d",i);  nameRows[9+ii]=&auxnameRows[9+ii][0];
      }





//-----------------  write the COLUMNS  section







//  Column variable  m1
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
        Coefficients[i*4]=    Ox[i];
        Coefficients[i*4+1]=  Ox[i];
        Coefficients[i*4+2]= -Ox[i];
        Coefficients[i*4+3]= -Ox[i];
      }

//  Column variable  m2
      for(i=0; i< NpointsInFit ; i++) {
        Coefficients[NStructRows+i*4]=   -Ox[i];
        Coefficients[NStructRows+i*4+1]= -Ox[i];
        Coefficients[NStructRows+i*4+2]= Ox[i];
        Coefficients[NStructRows+i*4+3]= Ox[i];

      }

//  Column variable  q1
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[2*NStructRows+i*4]=    1.;
        Coefficients[2*NStructRows+i*4+1]=  1.;
        Coefficients[2*NStructRows+i*4+2]= -1.;
        Coefficients[2*NStructRows+i*4+3]= -1.;
      }

//  Column variable  q2
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[3*NStructRows+i*4]=   -1.;
        Coefficients[3*NStructRows+i*4+1]= -1.;
        Coefficients[3*NStructRows+i*4+2]=  1.;
        Coefficients[3*NStructRows+i*4+3]=  1.;
      }

//  Column variable  lambdap(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i)*NStructRows+0]= -M;
        Coefficients[(4+i)*NStructRows+1]= -M;
        Coefficients[(4+i)*NStructRows+2]= -M;
        Coefficients[(4+i)*NStructRows+3]=  M;
        Coefficients[(4+i)*NStructRows+4]=  1.;
      }
//  Column variable  lambdam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+NpointsInFit)*NStructRows+0]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+1]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+2]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+3]=  M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+4]=  1.;
      }
//  Column variable  sigmap(i)
      for(i=0; i< NpointsInFit ; i++) {

        Coefficients[(4+i+2*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+4]= -1.;
      }
//  Column variable  sigmam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+4]= -1.;
      }

//  Column variable  DUMMY
      for(i=0 ; i< NStructRows ; i++) {
        Coefficients[(4+4*NpointsInFit)*NStructRows+i]= 1.;
      }
//--------------------
      sprintf(&auxStructVarName[0][0],"m1");
      StructVarName[0] = &auxStructVarName[0][0];
      NRowsInWhichStructVarArePresent[0]= 4*NpointsInFit;

      sprintf(&auxStructVarName[1][0],"m2");
      StructVarName[1] = &auxStructVarName[1][0];
      NRowsInWhichStructVarArePresent[1]= 4*NpointsInFit;

      sprintf(&auxStructVarName[2][0],"q1");
      StructVarName[2] = &auxStructVarName[2][0];
      NRowsInWhichStructVarArePresent[2]= 4*NpointsInFit;

      sprintf(&auxStructVarName[3][0],"q2");
      StructVarName[3] = &auxStructVarName[3][0];
      NRowsInWhichStructVarArePresent[3]= 4*NpointsInFit;
      for(i=0; i< NpointsInFit ; i++) {
          sprintf(&auxStructVarName[4+i][0],"lamp%d",i);
          StructVarName[4+i] = &auxStructVarName[4+i][0];
          NRowsInWhichStructVarArePresent[4+i]= 5;

          sprintf(&auxStructVarName[4+NpointsInFit+i][0],"lamm%d",i);
          StructVarName[4+NpointsInFit+i] = &auxStructVarName[4+NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+2*NpointsInFit+i][0],"sigmap%d",i);
          StructVarName[4+2*NpointsInFit+i] = &auxStructVarName[4+2*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+2*NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+3*NpointsInFit+i][0],"sigmam%d",i);
          StructVarName[4+3*NpointsInFit+i] = &auxStructVarName[4+3*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+3*NpointsInFit+i]= 5;

      }
      sprintf(&auxStructVarName[4+4*NpointsInFit][0],"DUMMY");
      StructVarName[4+4*NpointsInFit] = &auxStructVarName[4+4*NpointsInFit][0];
      NRowsInWhichStructVarArePresent[4+4*NpointsInFit]= NStructRows;

//  for m1, m2, q1, q2
      for(i=0; i< 4; i++){
        for(ii=0; ii< NpointsInFit;ii++){
         sprintf(&aux[i*NStructRows+ii*4][0],"Ap%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4]=&aux[i*NStructRows+ii*4][0];
         sprintf(&aux[i*NStructRows+ii*4+1][0],"Am%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+1]=&aux[i*NStructRows+ii*4+1][0];
         sprintf(&aux[i*NStructRows+ii*4+2][0],"Bp%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+2]=&aux[i*NStructRows+ii*4+2][0];
         sprintf(&aux[i*NStructRows+ii*4+3][0],"Bm%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+3]=&aux[i*NStructRows+ii*4+3][0];
        }
      }

//  now for the    lamp*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4)*NStructRows+0][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+0]= &aux[(i+4)*NStructRows+0][0];
         sprintf(&aux[(i+4)*NStructRows+1][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+1]= &aux[(i+4)*NStructRows+1][0];
         sprintf(&aux[(i+4)*NStructRows+2][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+2]= &aux[(i+4)*NStructRows+2][0];
         sprintf(&aux[(i+4)*NStructRows+3][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+3]= &aux[(i+4)*NStructRows+3][0];
         sprintf(&aux[(i+4)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+4]= &aux[(i+4)*NStructRows+4][0];
      }

//  now for the    lamm*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+0][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+0]= &aux[(i+4+NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+1][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+1]= &aux[(i+4+NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+2][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+2]= &aux[(i+4+NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+3][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+3]= &aux[(i+4+NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+4]= &aux[(i+4+NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmap*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+0]= &aux[(i+4+2*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+1][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+1]= &aux[(i+4+2*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+2][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+2]= &aux[(i+4+2*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+3][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+3]= &aux[(i+4+2*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+4][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+4]= &aux[(i+4+2*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmam*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+0]= &aux[(i+4+3*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+1][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+1]= &aux[(i+4+3*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+2][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+2]= &aux[(i+4+3*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+3][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+3]= &aux[(i+4+3*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+4][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+4]= &aux[(i+4+3*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    DUMMY   variable
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows  +8*i][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+i*8  ]= &aux[(4+4*NpointsInFit)*NStructRows  +8*i][0];

         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+1+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+2+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+3+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+4+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+5+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+6+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+7+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0];
      }




//-----------------  write the RHS  section


      for(i=0 ; i< NpointsInFit ; i++) {
          ValueB[i*9]  =  Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+1]= -Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+2]= Delta[i]+2.*M;
          ValueB[i*9+3]= M-Delta[i]+2.*M;
          ValueB[i*9+4]=  Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+5]= -Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+6]= Delta[i]+2.*M;
          ValueB[i*9+7]= M-Delta[i]+2.*M;
          ValueB[i*9+8]= 1.;


      }




//-----------------  write the RANGES  section

      for(i=0 ; i< NpointsInFit ; i++) {
        ValueRanges[i]=1.;
        sprintf(&auxNameRanges[i][0],"LAMBDA%d",i);
        NameRanges[i]=&auxNameRanges[i][0];
      }


//-----------------  write the BOUNDS  section


      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i][0],"BV");
          TypeofBound[i]=&auxTypeofBound[i][0];
          sprintf(&auxBoundStructVarName[i][0],"lamp%d",i);
          BoundStructVarName[i]=&auxBoundStructVarName[i][0];
          BoundValue[i]=0.;
      }

      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i+NpointsInFit][0],"BV");
          TypeofBound[i+NpointsInFit]=&auxTypeofBound[i+NpointsInFit][0];
          sprintf(&auxBoundStructVarName[i+NpointsInFit][0],"lamm%d",i);
          BoundStructVarName[i+NpointsInFit]=&auxBoundStructVarName[i+NpointsInFit][0];
          BoundValue[i+NpointsInFit]=0.;
      }

          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]=&auxTypeofBound[2*NpointsInFit][0];


          sprintf(&auxBoundStructVarName[2*NpointsInFit][0],"DUMMY");
          BoundStructVarName[2*NpointsInFit]=&auxBoundStructVarName[2*NpointsInFit][0];
          BoundValue[2*NpointsInFit]=2.*M;




//-----






//----------------------  calling the minimizer


      int status= glp_main(
            nRows,nameRows,typeRows, //  ROWS info
            NStructVar, NStructRows, NRowsInWhichStructVarArePresent,  //  COLUMNS info
      StructVarName, NameRowsInWhichStructVarArePresent,  //  COLUMNS info
      Coefficients,  //  COLUMNS info
      ValueB,  // RHS  info
      nRanges, ValueRanges, NameRanges, //  RANGES  info
      nBounds, BoundValue, BoundStructVarName, TypeofBound //  BOUNDS info
//      ,final_values, TIMEOUT  //  timeout is in seconds.
      ,final_values
       );
     if (status != 0) return -100;	// fit failed




//------------------------------------------

     m1_result=final_values[0];
     m2_result=final_values[1];
     q1_result=final_values[2];
     q2_result=final_values[3];


//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA


     *qu = q1_result - q2_result;
     *emme = m1_result-m2_result ;



// taking into account the rotation that was performed and calculate emme and qu in the normal conformal plane

      if(fabs(cose-*emme*sine)> 1.e-10) {
        *qu=*qu/(cose-*emme*sine);
        *emme=(*emme*cose+sine)/(cose-*emme*sine);
        return 1;
      } else {    //  in this case the equation is   0 = x+*qu .
        if(fabs(sine+*emme*cose) < 1.e-10)  {
  cout<<" From PndSttFitSZspace, situation impossible in principle! Returning -1"
                    <<endl;
           return -1;
        }

        *emme=1.;
        *qu = *qu/(sine+*emme*cose);
        return 99;    //  in this case the equation is   0 = x+*qu .
      }





}













//----------end of function PndSttTrackFinderReal::PndSttFitSZspace












//----------begin of function PndSttTrackFinderReal::PndSttFitSZspacebis


     Short_t PndSttTrackFinderReal::PndSttFitSZspacebis(
                                                     UShort_t nSkewHitsinTrack,
                                                     Double_t *S,
                                                     Double_t *Z,
                                                     Double_t *DriftRadius,
                                                     Double_t FInot,
                                                     UShort_t NMAX,
                                                     Double_t *emme
                                                            )
{







    //   definition of variables for the glpsol  solver
   //    ROWS (for read_rows  function)
   //
   UShort_t  NpointsInFit = nSkewHitsinTrack-NMAX <0 ?  nSkewHitsinTrack :  NMAX;
   int    nRows= NpointsInFit*9 +1;
   int typeRows[nRows];
   char * nameRows[nRows];
   char  auxnameRows[nRows][20];
//-------  end ROWS information
//--------begin COLUMNS information
      int  NStructVar=5+NpointsInFit*4;  //  number of  structural variables
      int  NStructRows = 8*NpointsInFit ;  //  maximum number of ROWS in which a structural variable can be found
      double final_values[NStructVar];
      int  NRowsInWhichStructVarArePresent[NStructVar];
      char *StructVarName[NStructVar];
      char auxStructVarName[NStructVar][20];
      char *NameRowsInWhichStructVarArePresent[NStructVar*NStructRows];
      char aux[NStructVar*NStructRows][20];
//      double Coefficients[NStructVar][NStructRows];
      double Coefficients[NStructVar*NStructRows];
//--------end COLUMNS information
//--------begin RHS information
      double ValueB[9*NpointsInFit];
//--------end RHS information
//--------begin RANGES information
      int nRanges = NpointsInFit;
      double ValueRanges[nRanges];
      char *NameRanges[nRanges];
      char auxNameRanges[nRanges][20];
//--------end RANGES information
//--------start BOUNDS information
      int nBounds=2*NpointsInFit+3;
//      int nBounds=2*NpointsInFit+1;
      double BoundValue[nBounds];
      char *BoundStructVarName[nBounds];
      char auxBoundStructVarName[nBounds][20];
      char *TypeofBound[nBounds];
      char auxTypeofBound[nBounds][20];
//--------end BOUNDS information


//----------------------------------------------------







     Double_t M = 50.,
              m_result,
              q_result,
              A,
              alfetta,
              angle,
              offsety,
              Ox[nmaxHits],
              Oy[nmaxHits],
              Delta[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

//     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --



//  rotation of 90 degrees

      for(i=0;i<nSkewHitsinTrack; i++){


       Ox[i] = S[ i ] - FInot;
       Oy[i] = -Z[ i ];

	Delta[i] = 3.*StrawRadius;   //  StrawRadius now is 0.5 cm

      }

//-----------------  write the ROWS  section

//--------
      sprintf(&auxnameRows[0][0],"OBJECT");
      nameRows[0]=&auxnameRows[0][0];
      typeRows[0]=GLP_FR;
      for(i=0 ; i< NpointsInFit ; i++) {
       ii=9*i;
       typeRows[1+ii]=GLP_UP;typeRows[2+ii]=GLP_UP;typeRows[3+ii]=GLP_UP;typeRows[4+ii]=GLP_UP;
       typeRows[5+ii]=GLP_UP;typeRows[6+ii]=GLP_UP;typeRows[7+ii]=GLP_UP;typeRows[8+ii]=GLP_UP;
       typeRows[9+ii]=GLP_LO;

       sprintf(&(auxnameRows[1+ii][0]),"Ap%d",i);  nameRows[1+ii]=&auxnameRows[1+ii][0];
       sprintf(&(auxnameRows[2+ii][0]),"Bp%d",i);  nameRows[2+ii]=&auxnameRows[2+ii][0];
       sprintf(&(auxnameRows[3+ii][0]),"Cp%d",i);  nameRows[3+ii]=&auxnameRows[3+ii][0];
       sprintf(&(auxnameRows[4+ii][0]),"Dp%d",i);  nameRows[4+ii]=&auxnameRows[4+ii][0];
       sprintf(&(auxnameRows[5+ii][0]),"Am%d",i);  nameRows[5+ii]=&auxnameRows[5+ii][0];
       sprintf(&(auxnameRows[6+ii][0]),"Bm%d",i);  nameRows[6+ii]=&auxnameRows[6+ii][0];
       sprintf(&(auxnameRows[7+ii][0]),"Cm%d",i);  nameRows[7+ii]=&auxnameRows[7+ii][0];
       sprintf(&(auxnameRows[8+ii][0]),"Dm%d",i);  nameRows[8+ii]=&auxnameRows[8+ii][0];
       sprintf(&(auxnameRows[9+ii][0]),"LAMBDA%d",i);  nameRows[9+ii]=&auxnameRows[9+ii][0];
      }





//-----------------  write the COLUMNS  section


//  Column variable  m1
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
        Coefficients[i*4]=    Ox[i];
        Coefficients[i*4+1]=  Ox[i];
        Coefficients[i*4+2]= -Ox[i];
        Coefficients[i*4+3]= -Ox[i];
      }

//  Column variable  m2
      for(i=0; i< NpointsInFit ; i++) {
        Coefficients[NStructRows+i*4]=   -Ox[i];
        Coefficients[NStructRows+i*4+1]= -Ox[i];
        Coefficients[NStructRows+i*4+2]= Ox[i];
        Coefficients[NStructRows+i*4+3]= Ox[i];

      }

//  Column variable  q1
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[2*NStructRows+i*4]=    1.;
        Coefficients[2*NStructRows+i*4+1]=  1.;
        Coefficients[2*NStructRows+i*4+2]= -1.;
        Coefficients[2*NStructRows+i*4+3]= -1.;
      }

//  Column variable  q2
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[3*NStructRows+i*4]=   -1.;
        Coefficients[3*NStructRows+i*4+1]= -1.;
        Coefficients[3*NStructRows+i*4+2]=  1.;
        Coefficients[3*NStructRows+i*4+3]=  1.;
      }

//  Column variable  lambdap(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i)*NStructRows+0]= -M;
        Coefficients[(4+i)*NStructRows+1]= -M;
        Coefficients[(4+i)*NStructRows+2]= -M;
        Coefficients[(4+i)*NStructRows+3]=  M;
        Coefficients[(4+i)*NStructRows+4]=  1.;
      }
//  Column variable  lambdam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+NpointsInFit)*NStructRows+0]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+1]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+2]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+3]=  M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+4]=  1.;
      }
//  Column variable  sigmap(i)
      for(i=0; i< NpointsInFit ; i++) {

        Coefficients[(4+i+2*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+4]= -1.;
      }
//  Column variable  sigmam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+4]= -1.;
      }

//  Column variable  DUMMY
      for(i=0 ; i< NStructRows ; i++) {
        Coefficients[(4+4*NpointsInFit)*NStructRows+i]= 1.;
      }
//--------------------
      sprintf(&auxStructVarName[0][0],"m1");
      StructVarName[0] = &auxStructVarName[0][0];
      NRowsInWhichStructVarArePresent[0]= 4*NpointsInFit;

      sprintf(&auxStructVarName[1][0],"m2");
      StructVarName[1] = &auxStructVarName[1][0];
      NRowsInWhichStructVarArePresent[1]= 4*NpointsInFit;

      sprintf(&auxStructVarName[2][0],"q1");
      StructVarName[2] = &auxStructVarName[2][0];
      NRowsInWhichStructVarArePresent[2]= 4*NpointsInFit;

      sprintf(&auxStructVarName[3][0],"q2");
      StructVarName[3] = &auxStructVarName[3][0];
      NRowsInWhichStructVarArePresent[3]= 4*NpointsInFit;
      for(i=0; i< NpointsInFit ; i++) {
          sprintf(&auxStructVarName[3+i+1][0],"lamp%d",i);
          StructVarName[4+i] = &auxStructVarName[4+i][0];
          NRowsInWhichStructVarArePresent[4+i]= 5;

          sprintf(&auxStructVarName[4+NpointsInFit+i][0],"lamm%d",i);
          StructVarName[4+NpointsInFit+i] = &auxStructVarName[4+NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+2*NpointsInFit+i][0],"sigmap%d",i);
          StructVarName[4+2*NpointsInFit+i] = &auxStructVarName[4+2*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+2*NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+3*NpointsInFit+i][0],"sigmam%d",i);
          StructVarName[4+3*NpointsInFit+i] = &auxStructVarName[4+3*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+3*NpointsInFit+i]= 5;

      }
      sprintf(&auxStructVarName[4+4*NpointsInFit][0],"DUMMY");
      StructVarName[4+4*NpointsInFit] = &auxStructVarName[4+4*NpointsInFit][0];
      NRowsInWhichStructVarArePresent[4+4*NpointsInFit]= NStructRows;
//  for m1, m2, q1, q2
      for(i=0; i< 4; i++){
        for(ii=0; ii< NpointsInFit;ii++){
         sprintf(&aux[i*NStructRows+ii*4][0],"Ap%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4]=&aux[i*NStructRows+ii*4][0];
         sprintf(&aux[i*NStructRows+ii*4+1][0],"Am%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+1]=&aux[i*NStructRows+ii*4+1][0];
         sprintf(&aux[i*NStructRows+ii*4+2][0],"Bp%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+2]=&aux[i*NStructRows+ii*4+2][0];
         sprintf(&aux[i*NStructRows+ii*4+3][0],"Bm%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+3]=&aux[i*NStructRows+ii*4+3][0];
        }
      }

//  now for the    lamp*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4)*NStructRows+0][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+0]= &aux[(i+4)*NStructRows+0][0];
         sprintf(&aux[(i+4)*NStructRows+1][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+1]= &aux[(i+4)*NStructRows+1][0];
         sprintf(&aux[(i+4)*NStructRows+2][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+2]= &aux[(i+4)*NStructRows+2][0];
         sprintf(&aux[(i+4)*NStructRows+3][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+3]= &aux[(i+4)*NStructRows+3][0];
         sprintf(&aux[(i+4)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+4]= &aux[(i+4)*NStructRows+4][0];
      }

//  now for the    lamm*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+0][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+0]= &aux[(i+4+NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+1][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+1]= &aux[(i+4+NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+2][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+2]= &aux[(i+4+NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+3][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+3]= &aux[(i+4+NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+4]= &aux[(i+4+NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmap*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+0]= &aux[(i+4+2*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+1][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+1]= &aux[(i+4+2*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+2][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+2]= &aux[(i+4+2*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+3][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+3]= &aux[(i+4+2*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+4][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+4]= &aux[(i+4+2*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmam*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+0]= &aux[(i+4+3*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+1][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+1]= &aux[(i+4+3*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+2][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+2]= &aux[(i+4+3*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+3][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+3]= &aux[(i+4+3*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+4][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+4]= &aux[(i+4+3*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    DUMMY   variable
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows  +8*i][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+i*8  ]= &aux[(4+4*NpointsInFit)*NStructRows  +8*i][0];

         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+1+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+2+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+3+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+4+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+5+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+6+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+7+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0];
      }

//-----------------  write the RHS  section

      for(i=0 ; i< NpointsInFit ; i++) {
          ValueB[i*9]  =  Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+1]= -Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+2]= Delta[i]+2.*M;
          ValueB[i*9+3]= M-Delta[i]+2.*M;
          ValueB[i*9+4]=  Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+5]= -Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+6]= Delta[i]+2.*M;
          ValueB[i*9+7]= M-Delta[i]+2.*M;
          ValueB[i*9+8]= 1.;


      }


//-----------------  write the RANGES  section

      for(i=0 ; i< NpointsInFit ; i++) {
        ValueRanges[i]=1.;
        sprintf(&auxNameRanges[i][0],"LAMBDA%d",i);
        NameRanges[i]=&auxNameRanges[i][0];
      }

//-----------------  write the BOUNDS  section


      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i][0],"BV");
          TypeofBound[i]=&auxTypeofBound[i][0];
          sprintf(&auxBoundStructVarName[i][0],"lamp%d",i);
          BoundStructVarName[i]=&auxBoundStructVarName[i][0];
          BoundValue[i]=0.;
      }

      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i+NpointsInFit][0],"BV");
          TypeofBound[i+NpointsInFit]=&auxTypeofBound[i+NpointsInFit][0];
          sprintf(&auxBoundStructVarName[i+NpointsInFit][0],"lamm%d",i);
          BoundStructVarName[i+NpointsInFit]=&auxBoundStructVarName[i+NpointsInFit][0];
          BoundValue[i+NpointsInFit]=0.;
      }

          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]=&auxTypeofBound[2*NpointsInFit][0];
          sprintf(&auxBoundStructVarName[2*NpointsInFit][0],"DUMMY");
          BoundStructVarName[2*NpointsInFit]=&auxBoundStructVarName[2*NpointsInFit][0];
          BoundValue[2*NpointsInFit]=2.*M;



//   fixing q1
          sprintf(&auxTypeofBound[2*NpointsInFit+1][0],"FX");
          TypeofBound[2*NpointsInFit+1]=&auxTypeofBound[2*NpointsInFit+1][0];
          sprintf(&auxBoundStructVarName[2*NpointsInFit+1][0],"q1");
          BoundStructVarName[2*NpointsInFit+1]=&auxBoundStructVarName[2*NpointsInFit+1][0];
          BoundValue[2*NpointsInFit+1]= 0.;
//   fixing q2
          sprintf(&auxTypeofBound[2*NpointsInFit+2][0],"FX");
          TypeofBound[2*NpointsInFit+2]=&auxTypeofBound[2*NpointsInFit+2][0];
          sprintf(&auxBoundStructVarName[2*NpointsInFit+2][0],"q2");
          BoundStructVarName[2*NpointsInFit+2]=&auxBoundStructVarName[2*NpointsInFit+2][0];
          BoundValue[2*NpointsInFit+2]= 0.;

//-----






//----------------------  calling the minimizer

//  WHEN THE FIT WENT WELL, STATUS = 0

      int status= glp_main(
            nRows,nameRows,typeRows, //  ROWS info
            NStructVar, NStructRows, NRowsInWhichStructVarArePresent,  //  COLUMNS info
      StructVarName, NameRowsInWhichStructVarArePresent,  //  COLUMNS info
      Coefficients,  //  COLUMNS info
      ValueB,  // RHS  info
      nRanges, ValueRanges, NameRanges, //  RANGES  info
      nBounds, BoundValue, BoundStructVarName, TypeofBound //  BOUNDS info
//      ,final_values, TIMEOUT  //  timeout is in seconds.
      ,final_values
       );

	if (status != 0) return -100;

//------------------------------------------

     m1_result=final_values[0];
     m2_result=final_values[1];
//     q1_result=final_values[2];
//     q2_result=final_values[3];

//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA





// taking into account the rotation + traslation that was performed and calculate emme and qu

     *emme = m1_result-m2_result ;
//     *qu = FInot;

      if(fabs( (*emme)  )> 1.e-10) {
        *emme=-1./(*emme);
        return 1;
      } else {

        return -99;
      }





}



//----------end of function PndSttTrackFinderReal::PndSttFitSZspacebis






































//----------begin of function PndSttTrackFinderReal::PndSttFitwithKalman

/*
      void   PndSttTrackFinderReal::PndSttFitwithKalman(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t Pxini,
                                                     Double_t Pyini,
                                                     Double_t Pzini,
                                                     Double_t Ptras,
                                                     Double_t info[][7],
                                                     UShort_t nParallelHits,
                                                     UShort_t *ListParallelHits,
                                                     UShort_t nSkewHits,
                                                     UShort_t *ListSkewHits,
                                                     Double_t *S,
                                                     UShort_t *Infoparal,
                                                     UShort_t *Infoskew
                                                       )
{


      UShort_t i,j,flag,
               nTotal = nParallelHits+nSkewHits,
               BigList[nTotal];
      Double_t old,
               auxFivalues[nmaxHits],
               auxFiSkewvalues[nmaxHits],
               auxRvalues[nmaxHits],
               BigListFi[nTotal];



//  here there is the ordering of the hits

//   ordering of the parallel hits first

    for (j = 0; j< nParallelHits; j++){
      auxRvalues[j]=
                    info[ infoparal[ ListParallelHits[j] ]  ][0]*
                    info[ infoparal[ ListParallelHits[j] ]  ][0]+
                    info[ infoparal[ ListParallelHits[j] ]  ][1]*
                    info[ infoparal[ ListParallelHits[j] ]  ][1];
    }

    Merge_Sort( nParallelHits, auxRvalues, ListParallelHits);

    for (j = 0; j< nParallelHits; j++){              
      auxFivalues[j] = atan2( info[ infoparal[ ListParallelHits[j] ]  ][1]-oY,
                              info[ infoparal[ ListParallelHits[j] ]  ][0]-oX);
      if( auxFivalues[j] < 0. ) auxFivalues[j] += 2.*PI;
    }

//  fixing possible discontinuity between fi<2*PI and fi>0.
   for (old=auxFivalues[0],flag=0, j = 1; j< nParallelHits; j++){
      if( fabs(old - auxFivalues[j]) > PI ) {
        flag=1;
        break;
      } else {
        old=auxFivalues[j];
      }
   }
   if( flag==1) {
      for (j = 0; j< nParallelHits; j++){
        if( auxFivalues[j] < PI) auxFivalues[j] += 2.*PI;
      }
   }
//     now ordering of the skew hits

   if( flag==1) {
      for (j = 0; j< nSkewHits; j++){
       if( S[j] < PI) {
            auxFiSkewvalues[j] = S[j] + 2.*PI;
       } else {
            auxFiSkewvalues[j] = S[j];
       }
      }
   } else {
      for (j = 0; j< nSkewHits; j++){
       auxFiSkewvalues[j] = S[j];
      }
   }
 
    Merge_Sort( nSkewHits, auxFiSkewvalues, ListSkewHits);
//    merge the parallel and skew hits
     for(j = 0;j< nParallelHits; j++){
       BigListFi[j]=auxFivalues[j];
       BigList [j] = Infoparal[  ListParallelHits[i]  ] ;        
     }
      for(j=0; j<nSkewHits; j++){
       BigListFi[j]=auxFiSkewvalues[j+nParallelHits];
       BigList [i+nParallelHits] = Infoskew[  ListSkewHits[i]  ] ;
      }

    Merge_Sort(nTotal, BigListFi, BigList);

//  now decide if track ran clockwise or anticlockwise


    if( auxFivalues[0] > auxFivalues[nParallelHits]) {
      for(j=0; j<nTotal; j++){
       auxFivalues[j]=BigListFi[nTotal-1-j];
      }
      for(j=0; j<nTotal; j++){
       BigListFi[j]=auxFivalues[j];
      }
    }



//---------   end ordering




      PndSttTrack*      track = NULL;

      // STARTING VERTEX ERRORS
//      TVector3 StartPos    = *recovtx;
      TVector3 StartPos    = TVector3(0.,0.,0.);
      Double_t pterr, plerr;
      Double_t errxp, erryp, errzp;
      errxp = 10 * 0.02;                      // 200 micron * 10
      erryp = errxp;
      errzp = 10 * 0.15;                      // 1.5 mm     * 10
      TVector3 StartPosErr = TVector3(errxp, erryp, errzp);
      TVector3 StartMom    = TVector3(Pxini,Pyini,Pzini);
//      TVector3 mcStartMom = mctrack->GetMomentum();
      Double_t momerr;                        // = 4% of mc mom 
//      momerr = 0.04 *  mcStartMom.Mag();
      momerr = 0.04 *  Ptras;
      pterr = momerr;
      plerr = momerr;
      TVector3 StartMomErr = TVector3(pterr, pterr, plerr); 

//      Int_t pdg = mctrack->GetPdgCode();
      Int_t pdg = 13;

      TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
      TParticlePDG *fParticle= fdbPDG->GetParticle(pdg);
      Double_t  fCharge= fParticle->Charge()/3.;
      
      TVector3 u(0.,1.,0.);
      TVector3 v(0.,0.,1.);
      GFDetPlane pl(StartPos,u,v);

      GFAbsTrackRep* rep = 0;
      GeaneTrackRep *grep = new GeaneTrackRep(fPro,pl,StartMom,StartPosErr,StartMomErr,fCharge,pdg);
      grep->setPropDir(1); // propagate in flight direction!
      rep=grep;

      GFTrack* trk = new GFTrack(rep);
      GFTrackCand *cand = new GFTrackCand();
      int detId;
      for(int iPoint = 0; iPoint < nTotal; iPoint++)
 	{

          PndSttHit * currenthit = (PndSttHit*) GetHitFromCollections(BigList[iPoint]);
	  if(!currenthit) continue;
	  

  
	  detId = currenthit->GetDetectorID() ;

	  cand->addHit(detId, BigList[iPoint]);

      	}   //  end of       for(int iPoint = 0; iPoint < nTotal; iPoint++)



       trk->setCandidate(*cand); // here the candidate is copied! 

//----  now the Kalman
	trk->addHitVector(_theRecoHitFactory->createMany(trk->getCand()));
	GFKalman k;
        k.setLazy(1);
	k.setNumIterations(1);
	k.processTrack(trk);
//------ estrazione delle info dal Kalman secondo Lia
    TVector3 dum = trk->getCardinalRep()->getMom();
//------------
 
    delete grep;
    delete trk;
    delete cand;

 return; 

}


*/


//----------end of function PndSttTrackFinderReal::PndSttFitwithKalman








//----------begin of function PndSttTrackFinderReal::PndSttOrderingParallel

	void   PndSttTrackFinderReal::PndSttOrderingParallel(
		Double_t oX,
		Double_t oY,
		Double_t info[][7],
		UShort_t nParallelHits,
		UShort_t *ListParallelHits,
		UShort_t *Infoparal,
		Short_t  Charge,
		Double_t *Fi_initial_helix_referenceframe,
		Double_t *Fi_final_helix_referenceframe,
		Double_t *U,
		Double_t *V
							)
{




      UShort_t	i,j,
		tmp[nParallelHits];
      Double_t	aaa,
		b1,
		firstR2,
		lastR2,
		aux[nParallelHits];



//  here there is the ordering of the hits, under the assumption that the circumference
//  in XY goes through (0,0).
//  Moreover, the code before is supposed to have selected trajectories in XY with (Ox,Oy)
//  farther from (0,0) by > 0.9 * RminStrawDetector/2 and consequently Ox and Oy are not both 0.
//  The scheme for the ordering of the hit is as follows :
//  1)  order hits by increasing U or V of the conformal mapping; see Gianluigi's Logbook page 283;
//  2)  find the charge of the track by checking if it is closest to the center in XY
//	the first or the last of the ordered hits.
//  3)  in case, invert the ordering of U, V and ListParallelHits such that the first hits in the
//	list are alway those closer to the (0,0).


//   ordering of the hits

	aaa = atan2( oY, oX);  // atan2 defined between -PI and PI.

	// the following statement is necessary since for unknown reason the root interpreter
	// gives a weird error when using PI directly in the if statement below!!!!!!! I lost
	// 2 hours trying to figure this out!
	b1 = PI/4.;

	if((aaa>b1&&aaa<3.*b1) || (aaa>-3.*b1&&aaa<-b1)){//use U as ordering variable;
							//[case 1 or 3 Gianluigi's Logbook page 285].
		for (j = 0; j< nParallelHits; j++){
			U[j]=info[ Infoparal[ ListParallelHits[j] ]  ][0]/(
			info[ Infoparal[ ListParallelHits[j] ]  ][0]*
			info[ Infoparal[ ListParallelHits[j] ]  ][0]+
			info[ Infoparal[ ListParallelHits[j] ]  ][1]*
			info[ Infoparal[ ListParallelHits[j] ]  ][1]);
		}
		Merge_Sort( nParallelHits, U, ListParallelHits);

		if((aaa>b1&&aaa<3.*b1)){  //  case #1;
			if( Charge == -1){
				// inverting the order of the hits.
				for(i=0;i<nParallelHits;i++){
					tmp[i]=ListParallelHits[nParallelHits-1-i];
					aux[i] = U[nParallelHits-1-i];
				}
				for(i=0;i<nParallelHits;i++){
					ListParallelHits[i]=tmp[i];
					U[i] = aux[i];
				}
			}
			for (j = 0; j< nParallelHits; j++){
				V[j]=info[ Infoparal[ ListParallelHits[j] ]  ][1]/(
				info[ Infoparal[ ListParallelHits[j] ]  ][0]*
				info[ Infoparal[ ListParallelHits[j] ]  ][0]+
				info[ Infoparal[ ListParallelHits[j] ]  ][1]*
				info[ Infoparal[ ListParallelHits[j] ]  ][1]);
			}
		} else{  //  case # 3.
			if(Charge == 1){
				// inverting the order of the hits.
				for(i=0;i<nParallelHits;i++){
					tmp[i]=ListParallelHits[nParallelHits-1-i];
					aux[i] = U[nParallelHits-1-i];
				}
				for(i=0;i<nParallelHits;i++){
					ListParallelHits[i]=tmp[i];
					U[i] = aux[i];
				}
			}// end of  if( Charge ==1)
			for (j = 0; j< nParallelHits; j++){
				V[j]=info[ Infoparal[ ListParallelHits[j] ]  ][1]/(
				info[ Infoparal[ ListParallelHits[j] ]  ][0]*
				info[ Infoparal[ ListParallelHits[j] ]  ][0]+
				info[ Infoparal[ ListParallelHits[j] ]  ][1]*
				info[ Infoparal[ ListParallelHits[j] ]  ][1]);
			}
		}// end of  if((aaa>b1&&aaa<3.*b1))

	} else { // use V as ordering variable [case 2 or 4 Gianluigi's Logbook page 285].
		for (j = 0; j< nParallelHits; j++){
			V[j]=info[ Infoparal[ ListParallelHits[j] ]  ][1]/(
			info[ Infoparal[ ListParallelHits[j] ]  ][0]*
			info[ Infoparal[ ListParallelHits[j] ]  ][0]+
			info[ Infoparal[ ListParallelHits[j] ]  ][1]*
			info[ Infoparal[ ListParallelHits[j] ]  ][1]);
		}
		Merge_Sort( nParallelHits, V, ListParallelHits);

		if((aaa<=-3.*b1 || aaa>=3.*b1)){  //  case #2;
			if( Charge == -1){
				// inverting the order of the hits.
				for(i=0;i<nParallelHits;i++){
					tmp[i]=ListParallelHits[nParallelHits-1-i];
					aux[i] = V[nParallelHits-1-i];
				}
				for(i=0;i<nParallelHits;i++){
					ListParallelHits[i]=tmp[i];
					V[i] = aux[i];
				}
			}
			for (j = 0; j< nParallelHits; j++){
				U[j]=info[ Infoparal[ ListParallelHits[j] ]  ][0]/(
				info[ Infoparal[ ListParallelHits[j] ]  ][0]*
				info[ Infoparal[ ListParallelHits[j] ]  ][0]+
				info[ Infoparal[ ListParallelHits[j] ]  ][1]*
				info[ Infoparal[ ListParallelHits[j] ]  ][1]);
			}
		} else{  //  case # 4.
			if( Charge == 1){
				// inverting the order of the hits.
				for(i=0;i<nParallelHits;i++){
					tmp[i]=ListParallelHits[nParallelHits-1-i];
					aux[i] = V[nParallelHits-1-i];
				}
				for(i=0;i<nParallelHits;i++){
					ListParallelHits[i]=tmp[i];
					V[i] = aux[i];
				}
			}
			for (j = 0; j< nParallelHits; j++){
				U[j]=info[ Infoparal[ ListParallelHits[j] ]  ][0]/(
				info[ Infoparal[ ListParallelHits[j] ]  ][0]*
				info[ Infoparal[ ListParallelHits[j] ]  ][0]+
				info[ Infoparal[ ListParallelHits[j] ]  ][1]*
				info[ Infoparal[ ListParallelHits[j] ]  ][1]);
			}
		}

	} //  end of   if((aaa>b1&& ....






//  FI initial value (at 0,0  vertex) in the Helix reference frame

	*Fi_initial_helix_referenceframe = atan2(-oY,-oX) ;//  this is in order to be coherent
			//  with the calculatation of Fi, which is atan2(oY,oX). 
			//  atan2  is defined in [-PI,PI)
	if ( *Fi_initial_helix_referenceframe <0.)
			*Fi_initial_helix_referenceframe += 2.*PI;

//  FI of the last parallel hit in the Helix reference frame

	*Fi_final_helix_referenceframe = atan2(
		info[ Infoparal[ ListParallelHits[nParallelHits-1] ] ][1]-oY,
		info[ Infoparal[ ListParallelHits[nParallelHits-1] ] ][0]-oX
						);
	if ( *Fi_final_helix_referenceframe <0.)
			*Fi_final_helix_referenceframe += 2.*PI;

	if ( Charge > 0 ) {
		if( *Fi_final_helix_referenceframe> *Fi_initial_helix_referenceframe)
			*Fi_final_helix_referenceframe -= 2.*PI;
		if( *Fi_final_helix_referenceframe> *Fi_initial_helix_referenceframe)
			*Fi_final_helix_referenceframe = *Fi_initial_helix_referenceframe;
	} else {
		if( *Fi_final_helix_referenceframe< *Fi_initial_helix_referenceframe)
			*Fi_final_helix_referenceframe += 2.*PI;
		if( *Fi_final_helix_referenceframe< *Fi_initial_helix_referenceframe)
			*Fi_final_helix_referenceframe = *Fi_initial_helix_referenceframe;
	}




 return; 


}
//----------end of function PndSttTrackFinderReal::PndSttOrderingParallel






//----------begin of function PndSttTrackFinderReal::PndSttOrderingSkewandParallel

      void   PndSttTrackFinderReal::PndSttOrderingSkewandParallel(
			UShort_t *Infoparal,
			UShort_t *Infoskew,
			Double_t oX,
			Double_t oY,
			Double_t Rr,
			UShort_t nSkewHits,
			UShort_t *ListSkewHits,
			Double_t *SList, // this is rekated to the skew hits. IMPORTANT :
					// the index must be the ORIGINAL skew hit number,
					// therefore SList[Infoskew[ListSkewHits[*]]].
			Short_t  Charge,
			UShort_t nParHits,
			UShort_t *ListParHits,
			Double_t *U,
			Double_t *V,
			UShort_t *BigList // this is the final ordered Parallel+Skew list;
				// already in NATIVE hit number.
				)
{


      UShort_t	i,j,
		index[nSkewHits+nParHits],
		tmp[nSkewHits+nParHits],
		tmpList[nSkewHits];
      Double_t	aaa,
		b1,
		sign,
		aux[nSkewHits+nParHits];



//  here there is the ordering of the hits, under the assumption that the circumference
//  in XY goes through (0,0).
//  Moreover, the code before is supposed to have selected trajectories in XY with (Ox,Oy)
//  farther from (0,0) by > 0.9 * RminStrawDetector/2 and consequently Ox and Oy are not both 0.
//  The scheme for the ordering of the hit is as follows :
//  1)  order hits by increasing U of the conformal mapping; see Gianluigi's Logbook page 283;
//  2)  find the charge of the track by checking if it is closest to the center in XY
//	the first or the last of the ordered hits.



//   ordering of the hits

	aaa = atan2( oY, oX);  // atan2 defined between -PI and PI.

	// the following statement is necessary since for unknown reason the root interpreter
	// gives a weird error when using PI directly in the if statement below!!!!!!! I lost
	// 2 hours trying to figure this out!
	b1 = PI/4.;


	if(aaa>b1&&aaa<3.*b1|| (aaa>-3.*b1&&aaa<-b1)){  //  case #1 or #3;see Gianluigi's Logbook page 285.
		if( (aaa>b1&&aaa<3.*b1 && Charge == -1)||( aaa>-3.*b1&&aaa<-b1 && Charge == 1) )
				{  // for speeding up the ordering taking advantage
				    // that the parallel hits were earlier ordered and
				    //  apply the trick of multiplying by   -1.
			sign=-1.;
		} else {  //  normal calculation
			sign=1.;
		}

		for (j = 0 ; j< nParHits; j++){
			aux[j] = sign*U[j];
//			BigList[j]=Infoparal[ListParHits[j]];
//			index[j] = j;
		}
		for (j = 0; j< nSkewHits; j++){
			// this is U in conformal space
			aux[j+nParHits]=sign*(oX + Rr*cos(SList[Infoskew[ListSkewHits[j]]]))/
					(oX*oX+oY*oY+Rr*Rr + 2.*Rr*
					(oX*cos(SList[Infoskew[ListSkewHits[j]]])
					+oY*sin(SList[Infoskew[ListSkewHits[j]]])));
//			BigList[j+nParHits]=Infoskew[ListSkewHits[j]];
//			index[j+nParHits] = j+nParHits;
		}


	} else {    // use V as ordering variable
		    // [case 2 and 4 Gianluigi's Logbook page 285].

		if( ((aaa<=-3.*b1|| aaa>=3.*b1) && Charge == -1)
				|| ( -b1 <= aaa && aaa <= b1 && Charge == 1) ){
			sign=-1.;
		} else {
			sign=1.;
		}
		for (j = 0 ; j< nParHits; j++){
			aux[j] = sign*V[j];
//			BigList[j]=Infoparal[ListParHits[j]];
//			index[j] = j;
		}
		for (j = 0; j< nSkewHits; j++){
			// this is V in conformal space.
			aux[j+nParHits]=sign*(oY + Rr*sin(SList[Infoskew[ListSkewHits[j]]]))/
			(oX*oX+oY*oY+Rr*Rr + 2.*Rr*
				(oX*cos(SList[Infoskew[ListSkewHits[j]]])
				+oY*sin(SList[Infoskew[ListSkewHits[j]]])));
//			BigList[j+nParHits]=Infoskew[ListSkewHits[j]];
//			index[j+nParHits] = j+nParHits;
		}


	}  //  end of  if((aaa>b1&& ....


	for (j = 0 ; j< nParHits; j++){
		BigList[j]=Infoparal[ListParHits[j]];
		index[j] = j;
	}
	for (j = 0; j< nSkewHits; j++){
		BigList[j+nParHits]=Infoskew[ListSkewHits[j]];
		index[j+nParHits] = j+nParHits;
	}

	Merge_Sort( nSkewHits+nParHits, aux, index);


	for(i=0, j=0;i<nSkewHits+nParHits;i++){
		tmp[i]=BigList[index[i]];
		//  reorder the ListSkewHits also.
		if( index[i] >= nParHits ){
			tmpList[j] = ListSkewHits[index[i]-nParHits];
			j++;
		}
	}
	for(i=0;i<nSkewHits+nParHits;i++){
		BigList[i]= tmp[i];
	}
		//  reorder the ListSkewHits also.
	for(i=0;i<nSkewHits;i++){
		ListSkewHits[i]= tmpList[i];
	}


 return;

}
//----------end of function PndSttTrackFinderReal::PndSttOrderingSkewandParallel








//----------begin of function PndSttTrackFinderReal::PndSttOrdering

      void   PndSttTrackFinderReal::PndSttOrdering(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t info[][7],
                                                     UShort_t nParallelHits,
                                                     UShort_t *ListParallelHits,
                                                     UShort_t nSkewHits,
                                                     UShort_t *ListSkewHits,
                                                     Double_t *S,
                                                     UShort_t *Infoparal,
                                                     UShort_t *Infoskew,
                                                     UShort_t *nTotal,
                                                     UShort_t *BigList,
                                                     Short_t  * Charge
                                                       )
{

      *nTotal = nParallelHits+nSkewHits;

      UShort_t i,j,flag,
               aux[*nTotal];
      Double_t old,
               auxFivalues[nmaxHits],
               auxFiSkewvalues[nmaxHits],
               auxRvalues[nmaxHits],
               BigListFi[*nTotal];



//  here there is the ordering of the hits

//   ordering of the parallel hits is not necessary; already done previously in
//   PndSttOrderingParallel, also taking care of the Charge (when positive, the
//   ordering must be reversed).

/*
    for (j = 0; j< nParallelHits; j++){
      auxRvalues[j]=
                    info[ Infoparal[ ListParallelHits[j] ]  ][0]*
                    info[ Infoparal[ ListParallelHits[j] ]  ][0]+
                    info[ Infoparal[ ListParallelHits[j] ]  ][1]*
                    info[ Infoparal[ ListParallelHits[j] ]  ][1];
    }

    Merge_Sort( nParallelHits, auxRvalues, ListParallelHits);

*/


    for (j = 0; j< nParallelHits; j++){              
      auxFivalues[j] = atan2( info[ Infoparal[ ListParallelHits[j] ]  ][1]-oY,
                              info[ Infoparal[ ListParallelHits[j] ]  ][0]-oX);
      if( auxFivalues[j] < 0. ) auxFivalues[j] += 2.*PI;

    }

//  fixing possible discontinuity between fi<2*PI and fi>0.
   for (old=auxFivalues[0],flag=0, j = 1; j< nParallelHits; j++){
      if( fabs(old - auxFivalues[j]) > PI ) {
        flag=1;
        break;
      } else {
        old=auxFivalues[j];
      }
   }
   if( flag==1) {
      for (j = 0; j< nParallelHits; j++){
        if( auxFivalues[j] < PI) auxFivalues[j] += 2.*PI;
      }
   }

//   finding the charge of the track not necessary; already done prima.

/*
    if( auxFivalues[0] > auxFivalues[nParallelHits-1]) {
      *Charge =  1;
    }  else {
     *Charge =  -1;
    }
*/



//     now ordering of the skew hits
 if(nSkewHits>0){
   if( flag==1) {
      for (j = 0; j< nSkewHits; j++){
       if( S[Infoskew[ ListSkewHits[j] ]] < PI) {
            auxFiSkewvalues[j] = S[Infoskew[ ListSkewHits[j] ]] + 2.*PI;
       } else {
            auxFiSkewvalues[j] = S[Infoskew[ ListSkewHits[j] ]];
       }
      }
   } else {
      for (j = 0; j< nSkewHits; j++){
       auxFiSkewvalues[j] = S[Infoskew[ ListSkewHits[j] ]];
      }
   }
 
    Merge_Sort( nSkewHits, auxFiSkewvalues, ListSkewHits);
 }   //  end of   if(nSkewHits>0)







//    merge the parallel and skew hits
     for(j = 0;j< nParallelHits; j++){
       BigListFi[j]=auxFivalues[j];
       BigList[j] = Infoparal[  ListParallelHits[j]  ] ;        
// cout<<"from Ordering, Parallel; j= "<<j<<", n. Hit // in original numbering = "<<BigList[j]<<endl;
     }
      for(j=0; j<nSkewHits; j++){
       BigListFi[j+nParallelHits]=auxFiSkewvalues[j];
       BigList [j+nParallelHits] = Infoskew[  ListSkewHits[j]  ] ;
// cout<<"from Ordering, Skew; j= "<<j<<", n. Hit skew in original numbering = "<<BigList[j+nParallelHits]<<endl;
      }

    if(nSkewHits>0) Merge_Sort(*nTotal, BigListFi, BigList);





/*
// for POSITIVE charged tracks, the ordering based on the Fi angle must be reversed because hits at smaller
// distance from center have geatest Fi

     if(*Charge ==1) {
      for(j=0; j<*nTotal; j++){
       auxFivalues[j]=BigListFi[(*nTotal)-1-j];
       aux[j]=BigList[(*nTotal)-1-j];
      }
      for(j=0; j<*nTotal; j++){
       BigListFi[j]=auxFivalues[j];
       BigList[j]=aux[j];
      }
     }
*/


/*
    cout<<"Printout di prova, dopo ordinamento globale, carica traccia = "<<*Charge<<endl;
    for(j=0; j<*nTotal; j++){
cout<<"    j= "<<j<<", n. Hit in original numbering = "<<BigList[j]<<" e suo FI "<<BigListFi[j]<<endl;
    }
*/

//--------------






//---------   end ordering



 return; 

}
//----------end of function PndSttTrackFinderReal::PndSttOrdering







//----------start  function PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRange





      void   PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRange(
				Double_t oX,
				Double_t oY,
				Double_t R,
				Short_t  Charge,
				Double_t *Fi_low_limit,	// Fi (in XY Helix frame) lower limit using
					// the Stt detector minimum/maximum radius
					// Fi_low_limit is ALWAYS between 0. and 2PI
				Double_t *Fi_up_limit,// Fi (in XY Helix frame) upper limit using
					// the Stt detector maximum/minimum radius
					// Fi_up_limit is ALWAYS > Fi_low_limit and
					// possibly > 2PI.
				Short_t * status,//it is a vector; =0, all well; =1,
						// track contained completely between RMin
						// and RMax; = -1 track contained within RMin;
						// =-2 track outside RMax.
				Double_t Rmi,	// Rmin of cylindrical volume intersected by track;
				Double_t Rma	// Rmax of cylindrical volume intersected by track;
									)
{
//  The hits ALWAYS are contained between Fi_low_limit and Fi_up_limit;
//  the Point at (0,0) is NEVER contained between Fi_low_limit and Fi_up_limit.



// -------------- calculate the maximum fi and minimum fi spanned by this track,

// see logbook pag.270; by using the Rmin and Rmax of the straw detector.

//  working in the hypothesis that the starting point of the track is near (0,0) so that
//  R_vertex < RStrawDetectorMin

	bool	intersection_inner,
		intersection_outer;
	Double_t	teta1,
			teta2,
			tetavertex,
			a,
			cosT,
			cost,
			cosFi,
			cosfi,
			Fi,
			fi,
			FI0,
			Px,
			Py,
			tmp;


//	Rma += 1. ; // add a safety margin.
//	Rmi -= 1. ; // add a safety margin.




	a = sqrt(oX*oX+oY*oY);

	//  preliminary condition
	if(a + R <= Rmi )	// in this case there might be hits at radius < Rmi.
		 { *status = -1 ;return;}
	if( a >= R + Rma || R >= a + Rma)  // in this case there can be no hits with radius < Rma.
		 { *status = -2;return;}

	if( a - R >= Rmi ) intersection_inner = false; else intersection_inner = true;

	if( a + R <= Rma || a - R >= Rma  )
		 intersection_outer = false; else intersection_outer = true;

	if( (! intersection_inner) && (! intersection_outer) ){
		*Fi_low_limit = 0.;
		*Fi_up_limit = 2.*PI;
		*status = 1;
		return;
	} 

//	now the calculation

	FI0 = atan2(-oY,-oX);
	if( intersection_outer ){
		cosFi = (a*a + R*R - Rma*Rma)/(2.*R*a);
		if(cosFi<-1.) cosFi=-1.; else if(cosFi>1.) cosFi=1.;
		Fi = acos(cosFi);
	}

	if( intersection_inner ){
		cosfi = (a*a + R*R - Rmi*Rmi)/(2.*R*a);
		if(cosfi<-1.) cosfi=-1.; else if(cosfi>1.) cosfi=1.;
		fi = acos(cosfi);
	}


	if( Charge < 0.){ // this particle rotates counterclockwise when looking into the beam
		if( intersection_outer && intersection_inner){
			*Fi_low_limit=FI0 + fi;
			*Fi_up_limit= FI0 +Fi;

		} else if (intersection_inner) {
			*Fi_low_limit=FI0 + fi;
			*Fi_up_limit= FI0 - fi;
		} else {
			*Fi_low_limit=FI0 - Fi;
			*Fi_up_limit= FI0 + Fi;
		}	// end of    if( intersection_outer && intersection_inner



	} else {	// continuation of   if( Charge < 0.)

		if( intersection_outer && intersection_inner){
			*Fi_low_limit=FI0 - Fi;
			*Fi_up_limit= FI0 - fi;

		} else if (intersection_inner) {
			*Fi_low_limit=FI0 + fi;	// must invert because low limit must be < up limit
			*Fi_up_limit= FI0 - fi;
		} else {
			*Fi_low_limit=FI0 - Fi;
			*Fi_up_limit= FI0 + Fi;
		}	// end of    if( intersection_outer && intersection_inner


	}	// end of  if( Charge < 0.)




	if(*Fi_low_limit<0.) {
		*Fi_low_limit=fmod(*Fi_low_limit,2.*PI);
		*Fi_low_limit += 2.*PI;
	} else if (*Fi_low_limit>=2.*PI){
		*Fi_low_limit=fmod(*Fi_low_limit,2.*PI);
	}
	if(*Fi_up_limit<0.) {
		*Fi_up_limit=fmod(*Fi_up_limit,2.*PI);
		*Fi_up_limit += 2.*PI;
	} else if (*Fi_up_limit>=2.*PI){
		*Fi_up_limit=fmod(*Fi_up_limit,2.*PI);
	}

	//	Modify *Fi_up_limit by adding
	//	2PI if it is the case, in order to make *Fi_up_limit > *Fi_low_limit.
	if( *Fi_up_limit < *Fi_low_limit ) *Fi_up_limit += 2.*PI;
	if( *Fi_up_limit < *Fi_low_limit ) *Fi_up_limit = *Fi_low_limit;

	*status = 0;



      return;
}






//---------- end of  function PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRange











//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitswithRfromMC

  void PndSttTrackFinderReal::WriteMacroParallelHitswithRfromMC(
                   Int_t Nhits, Double_t info[][7],
                   UShort_t nTracksFoundSoFar,
                   bool *TypeConf,
                   Double_t *Ox,
                   Double_t *Oy,
                   Short_t * daTrackFoundaTrackMC
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu,
            gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, rrr, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];

      char nome[300], nome2[300];







//---------- parallel straws Macro now con anche le tracce MC

      sprintf(nome,"MacrowithRfromMCParallelHitswithMCEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
//      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
          }
       }



       for( i=0; i< nMCTracks ; i++) {
		Int_t icode;
        	Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica, KAPPA, FI0mc  ;
    		PndMCTrack* pMC;
		pMC = (PndMCTrack*) fMCTrackArray->At(i);
		if ( ! pMC ) continue ;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         	TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         	TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       		if (icode>1000000000) carica = 1.;
       		else  carica = fParticle->Charge()/3. ;    //   charge of track
		if( fabs(carica)<0.1) continue;
           	Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           	Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
    		if( fabs( pMC->GetMomentum().Z() )< 1.e-20) KAPPA = 99999999.;
    		else  KAPPA = -carica*0.001*BFIELD*CVEL/pMC->GetMomentum().Z();
     		FI0mc = fmod(Fifi+ PI, 2.*PI);



            fprintf(MACRO,"TEllipse* MC%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMC%d->SetFillStyle(0);\nMC%d->SetLineColor(3);\nMC%d->Draw();\n",
                     i,Cx,Cy,Rr,Rr,i,i,i);
       }


//-------------------------------   plotting all the tracks found, with R from corresponding MC track

    for(i=0; i<nTracksFoundSoFar; i++){

       if( daTrackFoundaTrackMC[i] == -1 )  continue;



		Int_t icode;
        	Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica, KAPPA, FI0mc  ;
    		PndMCTrack* pMC;
		pMC = (PndMCTrack*) fMCTrackArray->At(daTrackFoundaTrackMC[i]);
		if ( ! pMC ) continue ;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         	TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         	TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       		if (icode>1000000000) carica = 1.;
       		else  carica = fParticle->Charge()/3. ;    //   charge of track
	if( fabs(carica)<0.1) continue;
           	Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           	Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
    		if( fabs( pMC->GetMomentum().Z() )< 1.e-20) KAPPA = 99999999.;
    		else  KAPPA = -carica*0.001*BFIELD*CVEL/pMC->GetMomentum().Z();
     		FI0mc = fmod(Fifi+ PI, 2.*PI);


       rrr = Rr;
       double angolo = atan2(Oy[i],Ox[i]); 
       aaa = rrr*cos(angolo);
       bbb = rrr*sin(angolo);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);


    }

// -----------

      fprintf(MACRO,"}\n");
      fclose(MACRO);
       
//------------------------------------------------------------------------------------------------------------






    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitswithRfromMC








//----------start of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithRfromMC

  void PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithRfromMC(
                   Double_t KAPPA,Double_t FI0,Double_t D,Double_t Fi,Double_t R,
                   Int_t Nhits, Double_t info[][7],  Int_t Nincl, Int_t Minclinations[], Double_t inclination[][3],
                   Int_t imaxima, Int_t nMaxima 
                                                     )
 {



    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS, imc, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];




//-------------------  skew straws hits Macro now

      char  nome2[300],nome[300];
      FILE *MACRO;
      sprintf(nome,  "MacroParTrack%dSkewTrack%dSkewHitswithRfromMCEvent%d",imaxima,nMaxima, IVOLTE);
      sprintf(nome2,  "%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);

//KAPPA = 1./166.67 ;  FI0 = 1.5*PI;

      Smin=zmin = 1.e10;
      Smax=zmax = -zmin;
      index=0;

       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1. )   continue;     // exclude parallel straws

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;

        if( distance >= info[i][4] + Aellipsis1) continue;


// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

        if(
          fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
          distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
          ) {
cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
           continue;
          }
//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
        fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);

        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( i=1; i< Nhits; i++)


  if(index==0) goto nohits ;
  if( zmax < zmin ) goto nohits ;
  if( Smax < Smin ) goto nohits;
  aaa = Smax-Smin;
  Smin -= aaa*1.;
  Smax += aaa*1.;

  aaa = zmax-zmin;
  zmin -= aaa*0.05;
  zmax += aaa*0.05;

  if(Smax > 2.*PI) Smax = 2.*PI;
  if( Smin < 0.) Smin = 0.;

//  Smin=0.;
//  Smax=2.*PI;


  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",zmin,Smin,zmax,Smax);
  for( ii=0; ii< index; ii++) {
       fprintf(MACRO,"E%d->Draw();\n",ii);
  }

   deltaz = zmax-zmin;
   deltaS = Smax-Smin;
   fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmax-0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,zmax-0.05*deltaz);
   fprintf(MACRO,"Assex->Draw();\n");
   fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,Smax-0.05*deltaS,Smin+0.05*deltaS,Smax-0.05*deltaS);
   fprintf(MACRO,"Assey->Draw();\n");




// --------------------------------

//  plot della traccia trovata dal finder


  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* FOUND%d = new TLine(%f,%f,%f,%f);\nFOUND%d->SetLineColor(2);\nFOUND%d->Draw();\n",
                 i-Nmin,z1,0.,z2, 2.*PI,i-Nmin,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


//---------------------------------------------  qui ci aggiungo le traccie MC


 for(imc=0; imc<nMCTracks ; imc++){



		Int_t icode;
        	Double_t Rr, Dd, Fifi, Oxx, Oyy, Cx, Cy, Px, Py, carica, FI0mc  ;
    		PndMCTrack* pMC;
		pMC = (PndMCTrack*) fMCTrackArray->At(imc);
		if ( ! pMC ) continue ;
         	icode  = pMC->GetPdgCode() ;    //   PDG code of track
         	Oxx = pMC->GetStartVertex().X();    //   X of starting point track
         	Oyy = pMC->GetStartVertex().Y();    //   Y of starting point track
         	Px = pMC->GetMomentum().X();
         	Py = pMC->GetMomentum().Y();
         	aaa = sqrt( Px*Px + Py*Py);
         	Rr =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla
         	TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         	TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
       		if (icode>1000000000) carica = 1.;
       		else  carica = fParticle->Charge()/3. ;    //   charge of track
	if( fabs(carica)<0.1) continue;
           	Cx = Oxx + Py*1000./(BFIELD*CVEL*carica);
           	Cy = Oyy - Px*1000./(BFIELD*CVEL*carica);
    		if( fabs( pMC->GetMomentum().Z() )< 1.e-20) KAPPA = 99999999.;
    		else  KAPPA = -carica*0.001*BFIELD*CVEL/pMC->GetMomentum().Z();
     		FI0mc = fmod(Fifi+ PI, 2.*PI);
//     KAPPA=MCtruthTrkInfo[12][imc];
     FI0 = FI0mc;


  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* MC%d_%d = new TLine(%f,%f,%f,%f);\nMC%d_%d->SetLineColor(3);\nMC%d_%d->Draw();\n",
                 imc,i-Nmin,z1,0.,z2, 2.*PI,imc,i-Nmin,imc,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


   }  // end of for(imc=0; imc<nMCTracks ; imc++)









nohits: ;

      fprintf(MACRO,"}\n");
      fclose(MACRO);





 }

//----------end of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithRfromMC


//----------begin of function PndSttTrackFinderReal::AssociateFoundTrackstoMC

    void PndSttTrackFinderReal::AssociateFoundTrackstoMC(
		  Double_t info[][7],
                  UShort_t nTracksFoundSoFar,
                  UShort_t *nHitsinTrack,
                  UShort_t  ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                  UShort_t *nSkewHitsinTrack,
                  UShort_t  ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                  Short_t daTrackFoundaTrackMC[MAXTRACKSPEREVENT]
//                  Short_t *daMCTrackaTrackFound 
                                                        )
{

   bool		firstime,
		inclusionMC[nTracksFoundSoFar][nmaxHits],
		inclusionExp[nTracksFoundSoFar];

   UShort_t	ntoMCtrack[nTracksFoundSoFar],
		toMCtracklist[nTracksFoundSoFar][nmaxHits],
		toMCtrackfrequency[nTracksFoundSoFar][nmaxHits];

   UShort_t  i, j, jtemp,jexp;

   Short_t	enne,
		itemp,
		massimo;



   for(i=0; i<nTracksFoundSoFar;i++){
     daTrackFoundaTrackMC[i]=-1;
     inclusionExp[i]=true;
	for(j=0; j<nHitsinTrack[i]+nSkewHitsinTrack[i];j++){
		inclusionMC[i][j]=true;
	}
   }






     for(jexp=0; jexp< nTracksFoundSoFar ;jexp++){

	firstime=true;
	ntoMCtrack[jexp]=0;

// prima  gli hits paralleli ---------------------


	for(i=0; i<nHitsinTrack[jexp]; i++){
		enne = (Short_t)( info[ infoparal[ ListHitsinTrack[jexp][i] ] ][6]+0.01 );
		if(enne<0) continue;   //  hit not associated to any MC track; noise hit.
		if(firstime) {
			ntoMCtrack[jexp]=1;
			toMCtracklist[jexp][0]= enne;
			toMCtrackfrequency[jexp][0]=1;
			firstime = false;
		} else {

			for(j=0; j<ntoMCtrack[jexp]; j++){
				if( enne == toMCtracklist[jexp][j] ) {
					toMCtrackfrequency[jexp][j]++;
					goto out1 ;
				}
			}
			toMCtracklist[jexp][ ntoMCtrack[jexp] ] = enne;
			toMCtrackfrequency[jexp][ ntoMCtrack[jexp] ] = 1;
			ntoMCtrack[jexp]++;
out1:  ;
		}

	}   //  end of for(i=0; i<nHitsinTrack[jexp]; i++)



// poi gli hits skew ---------------------
	for(i=0; i<nSkewHitsinTrack[jexp]; i++){
		enne = (Short_t)( info[ infoskew[ ListSkewHitsinTrack[jexp][i] ] ][6]+0.01 );
		if(enne<0) continue;   //  hit not associated to any MC track; noise hit.
		if(firstime) {
			ntoMCtrack[jexp]=1;
			toMCtracklist[jexp][0]= enne;
			toMCtrackfrequency[jexp][0]=1;
			firstime = false;
		} else {
			for(j=0; j<ntoMCtrack[jexp]; j++){
				if( enne == toMCtracklist[jexp][j] ) {
					toMCtrackfrequency[jexp][j]++;
					goto out2 ;
				}
			}
			toMCtracklist[jexp][ ntoMCtrack[jexp] ] = enne;
			toMCtrackfrequency[jexp][ ntoMCtrack[jexp] ] = 1;
			ntoMCtrack[jexp]++;
out2:  ;
		}
	}   //  end of for(i=0; j<nHitsinTrack[jexp]; i++)



     }  // end of  for(jexp=0; jexp< nTracksFoundSoFar ;jexp++)


     itemp=0;
     while ( itemp > -1){
	itemp=-1;
	massimo = -1;
	for(jexp=0; jexp< nTracksFoundSoFar ;jexp++){
		if( !inclusionExp[jexp])  continue;
		for(i=0; i< ntoMCtrack[jexp]; i++){
			if( !inclusionMC[jexp][i])  continue;
			if( toMCtrackfrequency[jexp][i]>massimo){
				massimo=toMCtrackfrequency[jexp][i];
				itemp = toMCtracklist[jexp][i];
				jtemp = jexp;
			}
		}
	}
	if( itemp>-1 ){
		daTrackFoundaTrackMC[jtemp]=itemp;
		inclusionExp[jtemp]=false;
		inclusionMC[jtemp][itemp]=false;
	}
     }    //    end while ( itemp > -1)






    return;
}




//----------end of function PndSttTrackFinderReal::AssociateFoundTrackstoMC














//----------begin of function PndSttTrackFinderReal::AssociateFoundTrackstoMCbis

    void PndSttTrackFinderReal::AssociateFoundTrackstoMCbis(
		bool *keepit,
		  Double_t info[][7],
                  UShort_t nTracksFoundSoFar,
                  UShort_t nHitsinTrack[MAXTRACKSPEREVENT],
                  UShort_t  ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                  UShort_t nSkewHitsinTrack[MAXTRACKSPEREVENT],
                  UShort_t  ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                  Short_t daTrackFoundaTrackMC[MAXTRACKSPEREVENT]
                                                        )
{

   bool	firstime,
	inclusionMC[nTracksFoundSoFar][nmaxHits],
		inclusionExp[nTracksFoundSoFar];

   UShort_t	ntoMCtrack[nTracksFoundSoFar],
		toMCtrackfrequency[nTracksFoundSoFar][nmaxHits];

   UShort_t  i, j, jtemp,jexp;

   Short_t	enne,
		itemp,
		massimo,
		toMCtracklist[nTracksFoundSoFar][nmaxHits];



   for(i=0; i<nTracksFoundSoFar;i++){
//     daTrackFoundaTrackMC[i]=-1;  // initialization already done before!
	if(!keepit[i]){
		inclusionExp[i]=false;
		continue;
	}
	inclusionExp[i]=true;
	for(j=0; j<nHitsinTrack[i]+nSkewHitsinTrack[i];j++){
		inclusionMC[i][j]=true;
	}
   }



     for(jexp=0; jexp< nTracksFoundSoFar ;jexp++){

	if(!keepit[jexp]) continue;
	firstime=true;
	ntoMCtrack[jexp]=0;


// ------ only the parallel hits are taken into consideration
	for(i=0; i<nHitsinTrack[jexp]; i++){

		enne = (Short_t)( info[ infoparal[ ListHitsinTrack[jexp][i] ] ][6]+0.01 );
		if(enne<0) continue;   //  hit not associated to any MC track; noise hit.
		if(firstime) {
			ntoMCtrack[jexp]=1;
			toMCtracklist[jexp][0]= enne;
			toMCtrackfrequency[jexp][0]=1;
			firstime = false;
		} else {
			for(j=0; j<ntoMCtrack[jexp]; j++){
				if( enne == toMCtracklist[jexp][j] ) {
					toMCtrackfrequency[jexp][j]++;
					goto out1 ;
				}
			}
			toMCtracklist[jexp][ ntoMCtrack[jexp] ] = enne;
			toMCtrackfrequency[jexp][ ntoMCtrack[jexp] ] = 1;
			ntoMCtrack[jexp]++;
out1:  ;
		}
	}   //  end of for(i=0; i<nHitsinTrack[jexp]; i++)



     }  // end of  for(jexp=0; jexp< nTracksFoundSoFar ;jexp++)


     itemp=0;
     while ( itemp > -1){
	itemp=-1;
	massimo = -1;
	for(jexp=0; jexp< nTracksFoundSoFar ;jexp++){
		if( !inclusionExp[jexp])  continue;
		for(i=0; i< ntoMCtrack[jexp]; i++){
			if( !inclusionMC[jexp][i])  continue;
			if( toMCtrackfrequency[jexp][i]>massimo){
				massimo=toMCtrackfrequency[jexp][i];
				itemp = toMCtracklist[jexp][i];
				jtemp = jexp;
			}
		}
	}
	if( itemp>-1 ){
		daTrackFoundaTrackMC[jtemp]=itemp;
		inclusionExp[jtemp]=false;
		for(jexp=0; jexp<nTracksFoundSoFar;jexp++){
			if( !inclusionExp[jexp])  continue;
			for(int jk=0;jk<ntoMCtrack[jexp];jk++){
				if( itemp==toMCtracklist[jexp][jk]){
					inclusionMC[jexp][jk]=false;
				}
			}
		}
	}
     }    //    end while ( itemp > -1)

  return;


}




//----------end of function PndSttTrackFinderReal::AssociateFoundTrackstoMCbis











//---------- begin of function PndSttTrackFinderReal::PndSttInfoXYZParal




    void PndSttTrackFinderReal::PndSttInfoXYZParal(
                             Double_t info[][7],
                             UShort_t infopar,
                             Double_t Ox,
                             Double_t Oy,
                             Double_t R,
                             Double_t KAPPA,
                             Double_t FI0,
                             Short_t Charge,
                             Double_t *Posiz
                            )
{

   Double_t fi, norm, vers[2];

   vers[0] = Ox - info[infopar][0];
   vers[1] = Oy - info[infopar][1];
   norm = sqrt( vers[0]*vers[0] + vers[1]*vers[1] );

   if(norm < 1.e-20) {
     Posiz[0] = -999999999.;
     return;
   }
   





   if( fabs( R - fabs( norm - info[infopar][3] ) ) // distance trajectory-drift radius
				<
		fabs( R - (norm + info[infopar][3]) )  ) {

	Posiz[0] = info[infopar][0] + info[infopar][3]*vers[0]/norm;
	Posiz[1] = info[infopar][1] + info[infopar][3]*vers[1]/norm;

   } else {

	Posiz[0] = info[infopar][0] - info[infopar][3]*vers[0]/norm;
	Posiz[1] = info[infopar][1] - info[infopar][3]*vers[1]/norm;

   }	// end of if ( fabs( R - fabs( Distance - info[infopar][3] ) ).....




//   Posiz[0] = info[infopar][0] + info[infopar][3]*vers[0]/norm;
//   Posiz[1] = info[infopar][1] + info[infopar][3]*vers[1]/norm;

   if( fabs(KAPPA)<1.e-10 ){
     Posiz[2] = -888888888.;
     return;
   } else if ( fabs(KAPPA) > 1.e10){
     Posiz[2] = -777777777.;
     return;
   }


   fi = atan2(-vers[1],-vers[0]);
   if(fi<0.)  fi += 2.*PI;

   if ( Charge > 0){
    if(fi > FI0 )  FI0 += 2.*PI;
//    Posiz[2] = (FI0-fi)/KAPPA;
   } else {
    if(fi < FI0 )  fi += 2.*PI;
   }
    Posiz[2] = (fi-FI0)/KAPPA;

   return;
}

//----------end of function PndSttTrackFinderReal::PndSttInfoXYZParal









//---------- begin of function PndSttTrackFinderReal::PndSttInfoXYZSkew




    void PndSttTrackFinderReal::PndSttInfoXYZSkew(
                             Double_t Z,       //  Z coordinate (center wire) of selected Skew hit
                             Double_t ZDrift,   // drift distance IN Z DIRECTION only, of selected Skew hit
                             Double_t S,
                             Double_t Ox,
                             Double_t Oy,
                             Double_t R,
                             Double_t KAPPA,
                             Double_t FI0,
                             Short_t Charge,
                             Double_t *Posiz      //  output
                            )
{
    Short_t  sign;

    Double_t bbb,
             tempZ[2],
             zmin, zmax, deltaz,
		zdist[2],
		zdist1,
		zdist2;



   Double_t Zline;

   if(fabs(KAPPA)< 1.e-10) {
     Posiz[0] = -999999999.;
     return;
   } else if (fabs(KAPPA)> 1.e10) {
     Posiz[0] = -888888888.;
     return;
   }

   Posiz[0] = Ox + R * cos(S);
   Posiz[1] = Oy + R * sin(S);

   if( Charge > 0 ) {
     if( S > FI0 )  {
        if(istampa>=3){ cout<<"from PndSttInfoXYZSkew : inconsistency, FI0 is not the maximum for this track "<<endl;
cout<<"  stampa da PndSttInfoXYZSkew,  "<<", Z hit = "<<Z<<", Zrift = "<<ZDrift<<", S = "<<S<<",  FI0 = "<<FI0<<endl;
}
        Posiz[0] = -777777777.;
        return;
      }
   }  else  {
     if( S < FI0 )  {
        if(istampa>=3) {cout<<"from PndSttInfoXYZSkew : inconsistency, FI0 is not the minimum for this track "<<endl;
cout<<"  stampa da PndSttInfoXYZSkew,  "<<", Z hit = "<<Z<<", Zrift = "<<ZDrift<<", S = "<<S<<",  FI0 = "<<FI0<<endl;
}
        Posiz[0] = -777777777.;
        return;
      }
   }







    if(KAPPA>0) {
     zmin = -FI0/KAPPA;
     zmax = (2.*PI-FI0)/KAPPA;
    }  else {
     zmax = -FI0/KAPPA;
     zmin = (2.*PI-FI0)/KAPPA;
    }
    deltaz = zmax-zmin;


       bbb=(S-FI0)/KAPPA;
      for(sign=0;sign<=1; sign ++){
       tempZ[sign]=Z+(2*sign-1)*ZDrift;
       if( tempZ[sign] > zmax ){
         tempZ[sign]=fmod( tempZ[sign]-zmax, deltaz) + zmin;
       } else if (tempZ[sign]<zmin){
         tempZ[sign]=fmod( tempZ[sign]-zmin, deltaz) + zmax;
       }


	zdist1 = fabs( bbb - tempZ[sign]);
	zdist2 = deltaz- zdist1;
	if( zdist2<0.) zdist2 =0.;	// protect against rounding errors.
	zdist[sign] = zdist1 < zdist2 ? zdist1 : zdist2;



      }  //  end of for(sign=0;sign<=1; sign++)


	zdist[0] < zdist[1] ? Posiz[2] = Z -  ZDrift : Posiz[2] = Z +  ZDrift ;




   return;
}

//----------end of function PndSttTrackFinderReal::PndSttInfoXYZSkew

//----------start of function PndSttTrackFinderReal::FixDiscontinuitiesFiangleinSZplane

  void PndSttTrackFinderReal::FixDiscontinuitiesFiangleinSZplane(
                          UShort_t TemporarynSkewHitsinTrack,
                          Double_t *S,
                          Double_t *Fi_initial_helix_referenceframe,
                          Short_t Charge
                                                                )
{

     UShort_t i;
     Double_t max, min;

     for(i=0, min = 9999., max = -9999.; i<TemporarynSkewHitsinTrack; i++){
        if( S[i] > max ) max = S[i];
        if( S[i] < min ) min = S[i];
     }


     if( max-min> PI) {
       for(i=0, min = 9999., max = -9999.; i<TemporarynSkewHitsinTrack; i++){
        if( S[i] < PI ) S[i] += 2.*PI;
        if( S[i] > max ) max = S[i];
        if( S[i] < min ) min = S[i];
       }
        
     }


     if( Charge >0 ){
       if( *Fi_initial_helix_referenceframe < max ) *Fi_initial_helix_referenceframe  += 2.*PI;
     } else {
       if( *Fi_initial_helix_referenceframe > min ) *Fi_initial_helix_referenceframe  -= 2.*PI;
     }

     return;

}
//----------end of function PndSttTrackFinderReal::FixDiscontinuitiesFiangleinSZplane

//----------begin of function PndSttTrackFinderReal::FindCharge

	void   PndSttTrackFinderReal::FindCharge(
		Double_t oX,
		Double_t oY,
		Double_t info[][7],
		UShort_t nParallelHits,
		UShort_t *ListParallelHits,
		UShort_t *Infoparal,
		Short_t  * Charge
				)
{

	UShort_t ihit,
			nleft,
			nright;

	Double_t cross,
		 disq,
		 minl,
		 minr;


	// this methods works with the hypothesis that this track comes
	//  from (0,0)

	for(ihit=0, nleft=0, nright=0, minr = 9999999., minl = 9999999.; ihit<nParallelHits; ihit++){ 
	// find the Z component of the cross product between the vector from (0,0) to center of
	// circular trajectory [namely, (oX,oY) ]  and the Position vector of the center of the
	// parallel Hits [namely, (x,y)].

		cross = oX*info[ Infoparal[ ListParallelHits[ihit] ] ][1] -
			oY*info[ Infoparal[ ListParallelHits[ihit] ] ][0];

	// if  cross >0  hits stays 'on the left' (which means clockwise to go from the origin
	// to the hit following the smaller path) otherwise it stays 'on the right'.

		if (cross>0.) {
			disq =	info[ Infoparal[ ListParallelHits[ihit] ] ][0]*
				info[ Infoparal[ ListParallelHits[ihit] ] ][0]+
				info[ Infoparal[ ListParallelHits[ihit] ] ][1]*
				info[ Infoparal[ ListParallelHits[ihit] ] ][1];
			nleft++;
		} else {
			nright++;
		}
	}	// end of   for(ihit=0, nleft=0, nright=0;....

	if( nright> nleft) {
		*Charge = -1;
	} else if ( nleft > nright) {
		*Charge = 1;
	} else {	// then choose according the closest hit ti the center
		if( minr < minl ) *Charge = -1;
		else  *Charge = 1;
	}



}
//----------end of function PndSttTrackFinderReal::FindCharge


//----------begin of function PndSttTrackFinderReal::SttParalCleanup



  bool PndSttTrackFinderReal::SttParalCleanup(
				Double_t GAP,
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				UShort_t &nHits,
				UShort_t *ListHits,
				Double_t info[][7],
				Double_t RStrawDetMin,
				Double_t RStrawDetInnerParMax,
				Double_t RStrawDetOuterParMin,
				Double_t RStrawDetMax
						)
{
// this method does 3 things :
//
//	1)  finds the entrance and exit points in the STT parallel volumes of the current track;
//	2)  eliminates from the track hit list possible spurious hits that are not encompassed
//		by the entrance and exit point;
//	3)  eliminates the tracks if the hit sequence is not continuous enough.


	bool ConsiderLastHit;

	Short_t flagInnerStt,
		flagOuterStt;

	UShort_t	ihit,
			nInnerHits,
			nOuterHits,
			nIntersections[2],
			ListInnerHits[nHits],
			ListOuterHits[nHits];

	Double_t	FiStart,
			r,
			Xcross[2],
			Ycross[2],
			XintersectionList[12][2], // second index =0 --> inner Hexagon, =1 --> outer.
			YintersectionList[12][2]; // first index : all the possible intersections
						  // (up to 12 intersections).

//------------------------
//------------------
//   separation of inner Parallel Stt hits from outer Parallel Stt hits.
	SeparateInnerOuterParallel(

				// input
				nHits,
				ListHits,
				info,
				RStrawDetInnerParMax,

				// output
				&nInnerHits,
				ListInnerHits,
				&nOuterHits,
				ListOuterHits
				);

//------------------------------------------
	// find the entrance and exit of the track in the Inner Left Parallel Straw region.
	// This region is bounded by two Hexagons, and it has the target gap in the middle.
	flagInnerStt=FindTrackEntranceExitbiHexagonLeft(
				GAP,
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
				RStrawDetMin,
				ApotemaMaxInnerParStraw,
				Xcross,
				Ycross
				);
	// find the entrance and exit of the track in the Inner Right Parallel Straw region.
	// This region is bounded by two Hexagons, and it has the target gap in the middle.
	flagInnerStt=FindTrackEntranceExitbiHexagonRight(
				GAP,
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
				RStrawDetMin,
				ApotemaMaxInnerParStraw,
				Xcross,
				Ycross
				);
//-----------------

	// find the entrance and exit of the track in the Inner Parallel Straw region.
	// This region is bounded by two Hexagons, and it has the target gap in the middle.
	flagInnerStt=FindTrackEntranceExitbiHexagon(
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
				RStrawDetMin,
				ApotemaMaxInnerParStraw,
				Xcross,
				Ycross
				);
	if (!(flagInnerStt == 0 || flagInnerStt == 2)) {
		 return false;
		}
	if (flagInnerStt == -99 ){
			cout<<"PndSttTrackFinderReal::SttParalCleanup,"<<
			" contraddiction,inner, nIntersections[0]="<<
			nIntersections[0]<<"<2, returning false!\n";
			return false;
	}
	if( nInnerHits==0) {
	 return false;
	 }

//-------------  cleanup of the spurious tracks first using the inner parallel straws.

	//  if there are also Outer Parallel hits, then require continuity of hits
	//  also at the external border of the inner parallel straw section (ConsiderLastHit=true).


	if( nInnerHits<nHits) ConsiderLastHit=true;
	else	ConsiderLastHit=false;

	if ( BadTrack_ParStt(
			Oxx,
			Oyy,
			Rr,
			Charge,
			Xcross,  // Xcross[0]=point of entrance; Xcross[1]=point of exit.
			Ycross,
			ConsiderLastHit,
			nInnerHits,
			ListInnerHits,
			info,
			RStrawDetMin,
			RStrawDetInnerParMax,
			1.1*DiameterStrawTube,	//  cut of proximity between hits.
			1	// maximum allowed # consecutive hits with distance > cut.
					)
	   ) {
		return false;
	}
	if( flagInnerStt == 2) return true;



//-----------------------------------------------------

	if(nOuterHits==0){
		return true;	// at this point of the code the absence of outer parallel hits
					// is possible (= track with very high Pz).
	}
//------------
	// find the entrance and exit of the track in the Outer Parallel Straw region, Left side.
	// This region is bounded by a Hexagon (inner), a Circle (outer) and it has
	// the target gap in the middle.
	flagOuterStt=FindTrackEntranceExitHexagonCircleLeft(
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
				ApotemaMinOuterParStraw,
				RStrawDetMax,
				GAP,
				Xcross,
				Ycross
				);

//------------
	// find the entrance and exit of the track in the Outer Parallel Straw region, Right side.
	// This region is bounded by a Hexagon (inner), a Circle (outer) and it has
	// the target gap in the middle.
	flagOuterStt=FindTrackEntranceExitHexagonCircleRight(
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
				ApotemaMinOuterParStraw,
				RStrawDetMax,
				GAP,
				Xcross,
				Ycross
				);


//------------
	// find the entrance and exit of the track in the Outer Parallel Straw region.
	// This region is bounded by a Hexagon (inner), a Circle (outer) and it has
	// the target gap in the middle.
	flagOuterStt=FindTrackEntranceExitHexagonCircle(
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
				ApotemaMinOuterParStraw,
				RStrawDetMax,
				Xcross,
				Ycross
				);
	if (!(flagOuterStt == 0 || flagOuterStt == 2|| flagOuterStt == -1)) return false;
	if (flagOuterStt == -99 ){
			cout<<"PndSttTrackFinderReal::SttParalCleanup,"<<
			" contraddiction,outer, nIntersections[0]="<<
			nIntersections[0]<<"<2, returning false!\n";
			return false;
	}
//-------------------------


//  cleanup of the spurious tracks now using the outer parallel straws.


	if ( BadTrack_ParStt(
			Oxx,
			Oyy,
			Rr,
			Charge,
			Xcross,  // Xcross[0]=point of entrance; Xcross[1]=point of exit.
			Ycross,
			false,	// for the Outer Parallel Stt at this stage don't require
				// continuity  of hits at the external border.
			nOuterHits,
			ListOuterHits,
			info,
			RStrawDetOuterParMin,
			RStrawDetMax,
			1.1*DiameterStrawTube,	//  cut of proximity between hits.
			1	// maximum allowed # consecutive hits with distance > cut.
					)
	   ){
		return false;
	}


//----------------------------------------------------------------------------


	return true;

};



//----------end of function PndSttTrackFinderReal::SttParalCleanup




//----------begin of function PndSttTrackFinderReal::SttSkewCleanup



  bool PndSttTrackFinderReal::SttSkewCleanup(
			Double_t GAP,
			Double_t Oxx,
			Double_t Oyy,
			Double_t Rr,
			Short_t  Charge,
			Double_t Start[3],
			UShort_t nHits,
			Double_t *auxS,
			Double_t RminStrawSkew,
			Double_t RmaxStrawSkew,
			bool ConsiderLastHit,
			Double_t cut,
			UShort_t maxnum
						)
{

	Short_t flagStt;

	UShort_t	i,
			ibad,
			nIntersections[2];

	Double_t	FiStart,
			r,
			Distance[nHits+1],
			Xcross[2],
			Ycross[2],
			XintersectionList[12][2], // second index =0 --> inner Hexagon, =1 --> outer.
			YintersectionList[12][2]; // first index : all the possible intersections
						  // (up to 12 intersections).

//------------------------------------------
	// find the entrance and exit of the track in the Skew Straw region.
	// This region is bounded by two Hexagons, and it has the target gap
	// in the middle. So Left is the left looking from downstream.

	flagStt=FindTrackEntranceExitbiHexagonLeft(
				GAP,
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
		ApotemaMinSkewStraw,
		ApotemaMaxSkewStraw, // Apotema is the distance of a Hexagonal side from (0,0)
				Xcross,
				Ycross
				);


	flagStt=FindTrackEntranceExitbiHexagonRight(
				GAP,
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
		ApotemaMinSkewStraw,
		ApotemaMaxSkewStraw, // Apotema is the distance of a Hexagonal side from (0,0)
				Xcross,
				Ycross
				);

	// find the entrance and exit of the track in the Skew Straw region.
	// This region is bounded by two Hexagons, and it has the target gap in the middle.
	flagStt=FindTrackEntranceExitbiHexagon(
				Oxx,
				Oyy,
				Rr,
				Charge,
				Start,
		ApotemaMinSkewStraw,
		ApotemaMaxSkewStraw, // Apotema is the distance of a Hexagonal side from (0,0)
				Xcross,
				Ycross
				);
	if (!(flagStt == 0 || flagStt == 2)) return false;
	if (flagStt == -99 ){
			cout<<"PndSttTrackFinderReal::SttSkewCleanup,"<<
			" contraddiction,skew, nIntersections[0]="<<
			nIntersections[0]<<"<2, returning false!\n";
			return false;
	}

//-------------------------------------------------------------------------


	//  if there are also Outer Parallel hits, then require continuity of hits
	//  also at the external border of the inner parallel straw section (ConsiderLastHit=true).

	ibad=0;
	Distance[0]= sqrt(
			(Oxx+Rr*cos(auxS[0])-Xcross[0])*(Oxx+Rr*cos(auxS[0])-Xcross[0]) +
			(Oyy+Rr*sin(auxS[0])-Ycross[0])*(Oyy+Rr*sin(auxS[0])-Ycross[0])
			);
		if(Distance[0]>cut){
			if(Distance[0]>4.*cut){
				return false;
			}
			ibad++;
		}

	for (i=1; i<nHits;i++){
		Distance[i] = fabs(Rr*( auxS[i]-auxS[i-1])); //length of the arc,not really the distance.
		if(Distance[i]>cut){
			if(Distance[i]>4.*cut){
				return false;
			}
			ibad++;
		}
	}	// end of do (i=1; i<nHits;i++)


	if( ConsiderLastHit ){

	// compute the distance of last hit to point at which track leaves this detector volume.
	   Distance[nHits] = sqrt(
		(Oxx+Rr*cos(auxS[nHits-1])-Xcross[1])*(Oxx+Rr*cos(auxS[nHits-1])-Xcross[1]) +
		(Oyy+Rr*sin(auxS[nHits-1])-Ycross[1])*(Oyy+Rr*sin(auxS[nHits-1])-Ycross[1])
				);
	   if( Distance[nHits]>cut ){
		if( Distance[nHits]>4.*cut){
//--------stampaggio
	if(istampa>=3) cout<<"da SttSkewCleanup,Distance[nHits], distanza catastrofica = "<<
	Distance[nHits]<<", !Eliminare!\n"
"\tcon il printout : Xcross[0] = "<<Xcross[0]<<", Ycross[0] = "<<Ycross[0]
	<<"\n\tcon il printout : Xcross[1] = "<<Xcross[1]<<", Ycross[1] = "<<Ycross[1]
<<"\n\tOxx = "<<Oxx
	<<", Oyy = "<<Oyy<<"\n\tRr "<<Rr<<"\n\tauxS[nHits-1] "<<auxS[nHits-1]<<
	"\tsuo X = "<<  Oxx+Rr*cos(auxS[nHits-1])<<", suo Y "<<Oyy+Rr*sin(auxS[nHits-1])<<endl;
//---------fine stampa

			return false;
		}
		ibad++;
	   }
	}	// end of  if( Distance[nHits]>cut )

//-------- stampaggi
if(istampa>=3) {
	for(int ic=0;ic<nHits;ic++){
		cout<<"\tda SttSkewCleanup, distanza = "<<Distance[ic]<<endl;
	}
if(ConsiderLastHit) cout<<"\tultimo hit considerato, distanza = "<<Distance[nHits]<<endl;
else cout<<"\tultimo hit NON considerato."<<endl;

}
//-------------------


	if( ibad > maxnum){
		 return false;
	}

	return true;






};



//----------end of function PndSttTrackFinderReal::SttSkewCleanup










//----------begin of function PndSttTrackFinderReal::BadTrack_ParStt
  bool PndSttTrackFinderReal::BadTrack_ParStt(
			Double_t Oxx,
			Double_t Oyy,
			Double_t Rr,
			Short_t Charge,
			Double_t Xcross[2],  // Xcross[0]=point of entrance;
						//  Xcross[1]=point of exit.
			Double_t Ycross[2],
			bool  ConsiderLastHit,
			UShort_t nHits,
			UShort_t* ListHits,
			Double_t info[][7],
			Double_t RStrawDetectorParMin,
			Double_t RStrawDetectorParMax,
			Double_t cut,
			UShort_t maxnum
				)
{
	UShort_t	ibad,
			ihit;

	Double_t	Distance[nHits+1];

	ibad=0;
	Distance[0]= sqrt(
		(info[ListHits[0]][0]-Xcross[0])*(info[ListHits[0]][0]-Xcross[0])+
		(info[ListHits[0]][1]-Ycross[0])*(info[ListHits[0]][1]-Ycross[0])
			);
	if(istampa>=3)cout<<"from BadTrack_ParStt, Stt || hit n. (original notation) "<<
	ListHits[0]<<", Distance = "<<Distance[0]<<endl;
	if(Distance[0]>cut){
		if(Distance[0]>4.*cut){
			return true;
		}
		ibad++;
	}

	for(ihit=1; ihit<nHits;ihit++){
		Distance[ihit]= sqrt(
			(info[ListHits[ihit]][0]-info[ListHits[ihit-1]][0])*
			(info[ListHits[ihit]][0]-info[ListHits[ihit-1]][0])+
			(info[ListHits[ihit]][1]-info[ListHits[ihit-1]][1])*
			(info[ListHits[ihit]][1]-info[ListHits[ihit-1]][1])
					);

if(istampa>=3)cout<<"from BadTrack_ParStt, Stt || hit n. (original notation) "<<
	ListHits[ihit]<<", Distance = "<<Distance[ihit]<<endl;
		if(Distance[ihit]>cut){
			if(Distance[ihit]>4.*cut){
				return true;
			}
			ibad++;
		}

	}	// end of   for(ihit=0,NinDet=0 ;ihit<nHits;ihit++)


	if( ConsiderLastHit ){

	// compute the distance of last hit to point at which track leaves this detector volume.
	   Distance[nHits] = sqrt(
	   (info[ListHits[nHits-1]][0]-Xcross[1])*(info[ListHits[nHits-1]][0]-Xcross[1])+
	   (info[ListHits[nHits-1]][1]-Ycross[1])*(info[ListHits[nHits-1]][1]-Ycross[1])
						);
if(istampa>=3)cout<<"from BadTrack_ParStt, Stt || hit n. (original notation) "<<
	ListHits[nHits-1]<<", Distance to boundary = "<<Distance[nHits]<<endl;
	   if( Distance[nHits]>cut ){
		if( Distance[nHits]>4.*cut){
			return true;
		}
		ibad++;
	   }
	}	// end of  if( Distance[nHits]>cut )


//-------- stampaggi
if(istampa>=3) {
	for(int ic=0;ic<nHits;ic++){
		cout<<"\tBadTrack_ParStt, distanza = "<<Distance[ic]<<endl;
	}
if(ConsiderLastHit) cout<<"\tBadTrack_ParStt,ultimo hit considerato, distanza = "<<Distance[nHits]<<endl;
else cout<<"\tBadTrack_ParStt,ultimo hit NON considerato."<<endl;

}
//-------------------
//-------- some plots
if(iplotta){
	for(int ic=0;ic<nHits;ic++){
		hdist->Fill(Distance[ic]);
	}

if(ConsiderLastHit)  hdistgoodlast->Fill( Distance[nHits]);
else  hdistbadlast->Fill( Distance[nHits]);

}
//---------------------------------------------


	if( ibad > maxnum) return true;
	return false;
}


//----------end of function PndSttTrackFinderReal::BadTrack_ParStt


//----------start  function PndSttTrackFinderReal::IntersectionsWithClosedPolygon

	Short_t  PndSttTrackFinderReal::IntersectionsWithClosedPolygon(
		//-------- inputs
		Double_t Ox,
		Double_t Oy,
		Double_t R,
		Double_t Rmi,	// min Apotema of hexagonal  volume intersected by track;
		Double_t Rma,	// max Apotema of hexagonal volume intersected by track;
		//-------- outputs
		UShort_t nIntersections[2],
		Double_t XintersectionList[][2],
		Double_t YintersectionList[][2]
						)
{


	// return integer convention :
	// -2 -->  track outside outer polygon;
	// -1 -->  track contained completely within inner polygon;
	// 0 -->  at least 1 intersection with inner polygon, at least 1 with outer polygon;
	// 1 -->  track contained completely between the two polygons;
	// 2 -->  track contained completely by larger polygons, with intersections in the smaller;
	// 3 -->  track completely outsiede the small polygon with intersections in the bigger.


	//  inner Hexagon --> 0
	//  outer Hexagon --> 1

	bool	internal[2],
		AtLeast1[2];

	UShort_t i,
		 is,
		 j,
		 Nintersections;

	Double_t mindist[2],
		 distance,
	//-------------------
	// a,b,c == coefficients of the implicit equations of the six sides of the Hexagon
	// centered at 0 :   a*x + b*y +c =0; see Gianluigi's logbook on page 277;
	// the coefficient  c  has to be multiplied by Erre.
	// The first side is 
		a[] = { 1./sqrt(3.) , 1., -1./sqrt(3.), 1./sqrt(3.) , 1. , -1./sqrt(3.) } ,
		b[] = { 1., 0. , 1., 1., 0. , 1. },
		c[] = { -2./sqrt(3.) , -1., 2./sqrt(3.), 2./sqrt(3.), 1., -2./sqrt(3.)},
	//----------------------

		Erre[] = {Rmi, Rma},  //  this is the distance from (0,0) 
					// of the Verteces of the Hexagon delimiting the Skew area
		tempX[2],
		tempY[2];

	// both hexagon_side_xlow and hexagon_side_xup must be multiplied by appropriate Erre;
	// sides of Hexagon ordered as a, b, c ..... in Gianluigi's logbook on page 280.
	Double_t
		hexagon_side_x[] = { 0., 1. , 1., 0., -1., -1., 0. },
		hexagon_side_y[] = { 2./sqrt(3.),1./sqrt(3.),-1./sqrt(3.),
					-2./sqrt(3.),-1./sqrt(3.), 1./sqrt(3.), 2./sqrt(3.)};



//-----------------------

//   find intersection with the 6 sides of the small exhagon delimiting the skew straws zone
//   see on page 277 of Gianluigi's logbook.

	// status  =0, at least 1 intersection with inner Hexagon, at least 1 intersection
	// with the outer Hexagon; =1, track contained completely between the
	// two Hexagons; = -1 track contained within inner Hexagon;
	// =-2 track outside outer Hexagon.


	for(i=0;i<2;i++){	// i=0 --> inner Hexagon, i= 1 --> outer Hexagon.
		AtLeast1[i] = false;
		nIntersections[i]=0;
		internal[i] = true;
		mindist[i]=999999.;
		for(is=0; is<6; is++){
			if ( IntersectionCircle_Segment(a[is],
						b[is],
						c[is]*Erre[i],
						hexagon_side_x[is]*Erre[i],
						hexagon_side_x[is+1]*Erre[i],
						hexagon_side_y[is]*Erre[i],
						hexagon_side_y[is+1]*Erre[i],
						Ox,
						Oy,
						R,
						&Nintersections,
						tempX,
						tempY,
						&distance // distance of (Ox,Oy) from line
							  // defined by  a*x+b*y+c=0.
							)
			   ){
			   AtLeast1[i]=true;
			   for(j=0;j<Nintersections;j++){
				XintersectionList[ nIntersections[i] ][i] =tempX[j];
				YintersectionList[ nIntersections[i] ][i] =tempY[j];
				nIntersections[i]++;
			   }
			}	// end of if ( IntersectionCircle_Segment( .....

			if(mindist[i]>distance) mindist[i]=distance;

			// the definition of 'internal' here is when the given Point
			// stays at the same side of the origin (0,0) with respect to
			// the given line of equation   a*x+b*y+c=0.
			 internal[i] = internal[i] && IsInternal(Ox,
								Oy,
								a[is],
								b[is],
								c[is]*Erre[i]
								);

		} // end of  for(is=0; is<6; is++)
	}  // end of  for(i=0;i<2;i++)


	if( (!AtLeast1[0]) && (!AtLeast1[1]) ){
	  if (!internal[1])  return -2;	// trajectory outside outer Hexagon.
	  if( R > mindist[1]) return -2;
	  if( !internal[0]) return 1; // trajectory contained between inner and outer Hexagon.
	  if( mindist[0] >= R)  return -1; //  trajectory contained in inner Hexagon.
	  return 1;	// trajectory contained between inner and outer Hexagon.
	} else if (AtLeast1[0] && AtLeast1[1] ){ // continuation of  if( (!AtLeast1[0]) && ...
	  return  0;
	} else if (AtLeast1[0]){
		return 2;
	}

	return 3;
}

//---------- end of  function PndSttTrackFinderReal::IntersectionsWithClosedPolygon



//----------start  function PndSttTrackFinderReal::IntersectionsWithOpenPolygon

	UShort_t  PndSttTrackFinderReal::IntersectionsWithOpenPolygon(
		//-------- inputs
		Double_t Ox, // Track parameter
		Double_t Oy, // Track parameter
		Double_t R, // Track parameter
		UShort_t nSides, // input, n. of Sides of open Polygon.
		Double_t *a, //  coefficient of formula :  aX + bY + c = 0 defining
		Double_t *b, //  the Polygon sides.
		Double_t *c,
		Double_t *Side_x,  // X,Y coordinate of the Sides vertices (in sequence, following
		Double_t *Side_y,  // the Polygon along.
		//-------- outputs
		Double_t *XintersectionList, // XintersectionList
		Double_t *YintersectionList // YintersectionList.
						)
{

	// this methods returns the n. of intersections.



	UShort_t i,
		 is,
		 j,
		 nIntersections,
		 Nintersections;

	Double_t mindist,
		 distance,
	//-------------------
	// a,b,c == coefficients of the implicit equations of the six sides of the Hexagon
	// centered at 0 :   a*x + b*y +c =0; see Gianluigi's logbook on page 277;
	// the coefficient  c  has to be multiplied by Erre.

		tempX[2],
		tempY[2];




//-----------------------

		nIntersections=0;
		for(is=0; is<nSides; is++){
			if ( IntersectionCircle_Segment(a[is],
						b[is],
						c[is],
						Side_x[is],
						Side_x[is+1],
						Side_y[is],
						Side_y[is+1],
						Ox,
						Oy,
						R,
						&Nintersections,
						tempX,
						tempY,
						&distance // distance of (Ox,Oy) from line
							  // defined by  a*x+b*y+c=0.
							)
			   ){
			   for(j=0;j<Nintersections;j++){
				XintersectionList[ nIntersections ] =tempX[j];
				YintersectionList[ nIntersections ] =tempY[j];
				nIntersections += Nintersections;
			   }
			}	// end of if ( IntersectionCircle_Segment( .....


		} // end of  for(is=0; is<nSides; is++)
//	}  // end of  for(i=0;i<2;i++)



	return nIntersections;
}

//---------- end of  function PndSttTrackFinderReal::IntersectionsWithOpenPolygon


//----------start  function PndSttTrackFinderReal::IntersectionsWithClosedbiHexagonLeft

	Short_t  PndSttTrackFinderReal::IntersectionsWithClosedbiHexagonLeft(
		//-------- inputs
		Double_t vgap,
		Double_t Ox,
		Double_t Oy,
		Double_t R,
		Double_t Ami,	// min Apotema of hexagonal  volume intersected by track;
		Double_t Ama,	// max Apotema of hexagonal volume intersected by track;
		//-------- outputs
		UShort_t *nIntersections,
		Double_t *XintersectionList,
		Double_t *YintersectionList
						)
{


	// return integer convention :
	// -1 -->  track outside outer perimeter;
	// 0 -->  at least 1 intersection with polygon;
  	// 1 -->  track contained completely between the two polygons;


	//  inner Hexagon --> 0
	//  outer Hexagon --> 1

	bool	internal,
		AtLeast1;

	UShort_t i,
		 is,
		 j,
		 Nintersections;

	Double_t aaa,
		 maxdistq,
		 distance,
	//-------------------
	// a,b,c == coefficients of the implicit equations of the 3 sides of the half inner Hexagon
	// plus 3 sides of the half outer Hexagon plus 2 vertical sides corresponding to the Gap :
	//    a*x + b*y +c =0; the numbering of these 8 sides foolows the convention of Gianluigi's
	// logbook on page 286.
a[] = {-1./sqrt(3.) ,	1.,	1./sqrt(3.),	1.,	1./sqrt(3.),	1.,	-1./sqrt(3.),	1.},
b[] = {1.,		0.,	1.,		0.,	1.,		0.,	1.,		0.},
c[] = {-2.*Ama/sqrt(3.),Ama,	2.*Ama/sqrt(3.),vgap/2.,2.*Ami/sqrt(3.),Ami,	-2.*Ami/sqrt(3.),vgap/2.},
	//----------------------

		tempX[2],
		tempY[2];

	// side_x and side_y are ordered as side1, side2, ..... in Gianluigi's logbook on page 286.
	Double_t
		side_x[] = { -vgap/2.,	-Ama ,	-Ama,	-vgap/2.,	-vgap/2.,	-Ami,
					-Ami,	-vgap/2.,	-vgap/2.},
		side_y[] = {(-0.5*vgap+2.*Ama)/sqrt(3.),	Ama/sqrt(3.),	-Ama/sqrt(3.),
			    -(-0.5*vgap+2.*Ama)/sqrt(3.),	-(-0.5*vgap+2.*Ami)/sqrt(3.),
			    -Ami/sqrt(3.),	Ami/sqrt(3.),	(-0.5*vgap+2.*Ami)/sqrt(3.),
			    (-0.5*vgap+2.*Ama)/sqrt(3.)	};



//-----------------------

//   find intersections (maximum 16) with the 8 sides.



		AtLeast1 = false;
		*nIntersections =0;
		internal = true;
		maxdistq=-9999.;
		for(is=0; is<8; is++){
			aaa = (side_x[is]-Ox)*(side_x[is]-Ox)+(side_y[is]-Oy)*(side_y[is]-Oy);
			if(aaa>maxdistq) maxdistq=aaa;
			aaa = (side_x[is+1]-Ox)*(side_x[is+1]-Ox)+(side_y[is+1]-Oy)*(side_y[is+1]-Oy);
			if(aaa>maxdistq) maxdistq=aaa;
			if ( IntersectionCircle_Segment(
						a[is],
						b[is],
						c[is],
						side_x[is],
						side_x[is+1],
						side_y[is],
						side_y[is+1],
						Ox,
						Oy,
						R,
						&Nintersections,
						tempX,
						tempY,
						&distance // distance of (Ox,Oy) from line
							  // defined by  a*x+b*y+c=0.
							)
			   ){
			   AtLeast1=true;
			   for(j=0;j<Nintersections;j++){
				XintersectionList[ *nIntersections ] =tempX[j];
				YintersectionList[ *nIntersections ] =tempY[j];
				(*nIntersections)++;
			   }
			}	// end of if ( IntersectionCircle_Segment( .....


			// the definition of 'internal' here is when the given Point
			// stays at the same side of the origin (0,0) with respect to
			// the given line of equation   a*x+b*y+c=0.
			if(is<3) {
				internal = internal && IsInternal(Ox,
								Oy,
								a[is],
								b[is],
								c[is]
								);
			} else {
				internal = internal && (!IsInternal(Ox,
								Oy,
								a[is],
								b[is],
								c[is]
								) );
			}

		} // end of  for(is=0; is<8; is++)


	if( !AtLeast1){
	  if (!internal)  return -1;// trajectory outside polygon.
	  if( maxdistq < R*R ) return -1;// trajectory outside polygon.
	  return 1;	// trajectory completely contained inside this Polygon.
	}
	return 0;

}

//---------- end of  function PndSttTrackFinderReal::IntersectionsWithClosedbiHexagonLeft

//----------start  function PndSttTrackFinderReal::IntersectionsWithClosedbiHexagonRight

	Short_t  PndSttTrackFinderReal::IntersectionsWithClosedbiHexagonRight(
		//-------- inputs
		Double_t vgap,
		Double_t Ox,
		Double_t Oy,
		Double_t R,
		Double_t Ami,	// min Apotema of hexagonal  volume intersected by track;
		Double_t Ama,	// max Apotema of hexagonal volume intersected by track;
		//-------- outputs
		UShort_t *nIntersections,
		Double_t *XintersectionList,
		Double_t *YintersectionList
						)
{


	// return integer convention :
	// -1 -->  track outside outer perimeter;
	// 0 -->  at least 1 intersection with polygon;
  	// 1 -->  track contained completely between the two polygons;


	//  inner Hexagon --> 0
	//  outer Hexagon --> 1

	bool	internal,
		AtLeast1;

	UShort_t i,
		 is,
		 j,
		 Nintersections;

	Double_t aaa,
		 maxdistq,
		 distance,
	//-------------------
	// a,b,c == coefficients of the implicit equations of the 3 sides of the half inner Hexagon
	// plus 3 sides of the half outer Hexagon plus 2 vertical sides corresponding to the Gap :
	//    a*x + b*y +c =0; the numbering of these 8 sides foolows the convention of Gianluigi's
	// logbook on page 286.
a[] = {1./sqrt(3.) ,	1.,	-1./sqrt(3.),	1.,	-1./sqrt(3.),	1.,	1./sqrt(3.),	1.},
b[] = {1.,		0.,	1.,		0.,	1.,		0.,	1.,		0.},
c[] = {-2.*Ama/sqrt(3.),-Ama,	2.*Ama/sqrt(3.),-vgap/2.,2.*Ami/sqrt(3.),-Ami,	-2.*Ami/sqrt(3.),-vgap/2.},
	//----------------------

		tempX[2],
		tempY[2];

	// side_x and side_y are ordered as side1, side2, ..... in Gianluigi's logbook on page 286.
	Double_t
		side_x[] = { vgap/2.,	Ama ,	Ama,	vgap/2.,	vgap/2.,	Ami,
					Ami,	vgap/2.,	vgap/2.},
		side_y[] = {(-0.5*vgap+2.*Ama)/sqrt(3.),	Ama/sqrt(3.),	-Ama/sqrt(3.),
			    -(-0.5*vgap+2.*Ama)/sqrt(3.),	-(-0.5*vgap+2.*Ami)/sqrt(3.),
			    -Ami/sqrt(3.),	Ami/sqrt(3.),	(-0.5*vgap+2.*Ami)/sqrt(3.),
			    (-0.5*vgap+2.*Ama)/sqrt(3.)	};



//-----------------------

//   find intersections (maximum 16) with the 8 sides.



		AtLeast1 = false;
		*nIntersections =0;
		internal = true;
		maxdistq=-9999.;
		for(is=0; is<8; is++){
			aaa = (side_x[is]-Ox)*(side_x[is]-Ox)+(side_y[is]-Oy)*(side_y[is]-Oy);
			if(aaa>maxdistq) maxdistq=aaa;
			aaa = (side_x[is+1]-Ox)*(side_x[is+1]-Ox)+(side_y[is+1]-Oy)*(side_y[is+1]-Oy);
			if(aaa>maxdistq) maxdistq=aaa;
			if ( IntersectionCircle_Segment(
						a[is],
						b[is],
						c[is],
						side_x[is],
						side_x[is+1],
						side_y[is],
						side_y[is+1],
						Ox,
						Oy,
						R,
						&Nintersections,
						tempX,
						tempY,
						&distance // distance of (Ox,Oy) from line
							  // defined by  a*x+b*y+c=0.
							)
			   ){
			   AtLeast1=true;
			   for(j=0;j<Nintersections;j++){
				XintersectionList[ *nIntersections ] =tempX[j];
				YintersectionList[ *nIntersections ] =tempY[j];
				(*nIntersections)++;
			   }
			}	// end of if ( IntersectionCircle_Segment( .....


			// the definition of 'internal' here is when the given Point
			// stays at the same side of the origin (0,0) with respect to
			// the given line of equation   a*x+b*y+c=0.
			if(is<3) {
				internal = internal && IsInternal(Ox,
								Oy,
								a[is],
								b[is],
								c[is]
								);
			} else {
				internal = internal && (!IsInternal(Ox,
								Oy,
								a[is],
								b[is],
								c[is]
								) );
			}

		} // end of  for(is=0; is<8; is++)


	if( !AtLeast1){
	  if (!internal)  return -1;// trajectory outside polygon.
	  if( maxdistq < R*R ) return -1;// trajectory outside polygon.
	  return 1;	// trajectory completely contained inside this Polygon.
	}
	return 0;

}

//---------- end of  function PndSttTrackFinderReal::IntersectionsWithClosedbiHexagonRight

//----------begin of function PndSttTrackFinderReal::IntersectionCircle_Segment

	bool PndSttTrackFinderReal::IntersectionCircle_Segment(
				Double_t a, // coefficients implicit equation.
				Double_t b, // of segment : a*x + b*y + c =0.
				Double_t c,
				Double_t P1x, // point delimiting the segment.
				Double_t P2x, // point delimiting the segment.
				Double_t P1y, // point delimiting the segment.
				Double_t P2y, // point delimiting the segment.
				Double_t Ox, // center of circle.
				Double_t Oy,
				Double_t R, // Radius of circle.
				UShort_t * Nintersections,
				Double_t XintersectionList[2],
				Double_t YintersectionList[2],
				Double_t *distance
								)
{

// this method finds the intersection of a circle with a segment. If the circle
// passes through an endpoint of the segment, that is considered an intersection also.

	bool status;

	Short_t ipossibility;

	Double_t aperp,
		 bperp,
		 cperp,
		 det,
		 distq,
		 dist1,
		 dist2,
		 length,
		 length_segmentq,
		 Rq,
		 x,
		 y,
		 Xintersection,
		 Yintersection;

	*Nintersections=0;
	det = a*a+b*b ;
	if(det < 1.e-20){
		cout<<"from  PndSttTrackFinderReal::IntersectionCircle_Segment :"
				<<" this is not the equation of a segment, return!\n";
		return false;
	}
	//  find if intersection circle - segment is possible.

	// check if there is an intersection (with the squares, it's the same!).
	distq = ( a*Ox+ b*Oy + c )*( a*Ox+ b*Oy + c )/det;
	*distance = sqrt(distq);
	Rq=R*R;
	length = Rq - distq;
	if(length <= 0. ) return false; // no intersection between trajectory and this
						// segment.
	length = sqrt(length);
	// coefficients of line perpendicular to input segment and passing for (Ox, Oy).
	aperp = -b;
	bperp = a;
	cperp = - aperp*Ox - bperp*Oy;

	// find intersection of segment with perpendicular : no need to check if
	// det is different from 0.
	Xintersection = (-bperp*c + b*cperp)/det;
	Yintersection = (-a*cperp + aperp*c)/det;
	det = sqrt(det);
	length_segmentq = (P1x-P2x)*(P1x-P2x) + (P1y-P2y)*(P1y-P2y);

	status = false;
	for(ipossibility=-1;ipossibility<2;ipossibility +=2){
		x = Xintersection + ipossibility*length*b/det ;
		y = Yintersection - ipossibility*length*a/det ;
		if ( (x-P1x)*(x-P1x)+(y-P1y)*(y-P1y) >  length_segmentq
						||
		     (x-P2x)*(x-P2x)+(y-P2y)*(y-P2y) >  length_segmentq
				    )  continue;
		status = true;
		XintersectionList[*Nintersections] = x;
		YintersectionList[*Nintersections] = y;
		(*Nintersections)++;
	}  //  end of  for(ipossibility=-1; ...


	return status;
}

//----------end of function PndSttTrackFinderReal::IntersectionCircle_Segment


//----------begin of function PndSttTrackFinderReal::IntersectionsWithGapSemicircle


	UShort_t PndSttTrackFinderReal::IntersectionsWithGapSemicircle(
			Double_t Oxx,
			Double_t Oyy,
			Double_t Rr,
			Double_t GAP,
			bool left,  // if true --> Left semicircle; false --> Right semicircle.
			Double_t Rma,
			Double_t *XintersectionList,
			Double_t *YintersectionList
						)
{

	UShort_t	nIntersectionsCircle;

	Double_t	cosFi,
			theta1,
			theta2,
			Theta1,
			Theta2,
			aaa,
			Fi,
			FI0,
			x1,
			x2,
			y1,
			y2;



	nIntersectionsCircle=0;
	aaa = sqrt(Oxx*Oxx+Oyy*Oyy);

	//  preliminary condition for having intersections between trajectory and  Circle.

	if( !( aaa >= Rr + Rma || Rr >= aaa + Rma) &&
		!( aaa + Rr <= Rma || aaa - Rr >= Rma  ) )	{

//	now the calculation

		FI0 = atan2(-Oyy,-Oxx);
		cosFi = (aaa*aaa + Rr*Rr - Rma*Rma)/(2.*Rr*aaa);
		if(cosFi<-1.) cosFi=-1.; else if(cosFi>1.) cosFi=1.;
		Fi = acos(cosFi);


		//  (x1, y1) and (x2,y2) are the intersections between the trajectory
		//  and the circle, in the laboratory reference frame.
		x1 = Oxx+Rr*cos(FI0 - Fi);
		y1 = Oyy+Rr*sin(FI0 - Fi);
		theta1 = atan2(y1,x1); // in this way theta1 is between -PI and PI.
		x2 = Oxx+Rr*cos(FI0 + Fi);
		y2 = Oyy+Rr*sin(FI0 + Fi);
		theta2 = atan2(y2,x2); // in this way theta2 is between -PI and PI.
		//  Theta1, Theta2 = angle of the edges of the outer circle + Gap in the laboratory frame.
		//  Theta1, Theta2 are angles between -PI/2 and +PI/2.
		if(!left){	//  Right (looking into the beam) Semicircle.
			Theta2 = atan2( sqrt(Rma*Rma-GAP*GAP/4.),GAP/2.);
			Theta1 = atan2( -sqrt(Rma*Rma-GAP*GAP/4.),GAP/2.);
			if( Theta1<= theta1 && theta1 <= Theta2 ){
				XintersectionList[nIntersectionsCircle]=x1;
				YintersectionList[nIntersectionsCircle]=y1;
				nIntersectionsCircle++;
			}
			if( Theta1<= theta2 && theta2 <= Theta2 ){
				XintersectionList[nIntersectionsCircle]=x2;
				YintersectionList[nIntersectionsCircle]=y2;
				nIntersectionsCircle++;
			}
		} else {	//  Left (looking into the beam) Semicircle.
			Theta2 = atan2( -sqrt(Rma*Rma-GAP*GAP/4.),-GAP/2.);
			Theta1 = atan2( sqrt(Rma*Rma-GAP*GAP/4.),-GAP/2.);
			if( Theta1<= theta1 || theta1 <= Theta2 ){
				XintersectionList[nIntersectionsCircle]=x1;
				YintersectionList[nIntersectionsCircle]=y1;
				nIntersectionsCircle++;
			}
			if( Theta1<= theta2 || theta2 <= Theta2 ){
				XintersectionList[nIntersectionsCircle]=x2;
				YintersectionList[nIntersectionsCircle]=y2;
				nIntersectionsCircle++;
			}
		}

	}  // end of   if (!( a >= Rr + Rma || .....

//---------------------------- end of calculation intersection with outer circle.

	return nIntersectionsCircle;


}
//----------end of function PndSttTrackFinderReal::IntersectionsWithGapSemicircle




//----------star of function PndSttTrackFinderReal::IsInternal
	bool PndSttTrackFinderReal::IsInternal(
			Double_t Px,	// point
			Double_t Py,
			Double_t Xtraslation,
			Double_t Ytraslation,
			Double_t Theta
					)
{


	// for explanations see Gianluigi's logbook on page 278-280.

	if( (Xtraslation-Px)*sin(Theta) + (Py-Ytraslation)*cos(Theta) >= 0. ) return true;
	else return false;


}
//----------end of function PndSttTrackFinderReal::IsInternal

//----------star of function PndSttTrackFinderReal::ChooseEntranceExit
	void PndSttTrackFinderReal::ChooseEntranceExit(
			Double_t Oxx,
			Double_t Oyy,
			Short_t flag,
			Short_t  Charge,
			Double_t FiStart,
			UShort_t nIntersections[2],
			Double_t XintersectionList[][2], //  second index =1 -->inner polygon;
			Double_t YintersectionList[][2], //  second index =2 -->outer polygon.
			Double_t Xcross[2],	// output
			Double_t Ycross[2]	// output
					)
{

	UShort_t i,
		 j;
// this method works under the hypothesis that flag=0 or 2 only.

	if(flag == 0) {
	  if(Charge > 0) {
	     for(j=0;j<2;j++){  // j=0 --> inner polygon; j=1 --> outer polygon.
		UShort_t auxIndex[nIntersections[j]];
		Double_t fi[nIntersections[j]];
		for( i=0;i<nIntersections[j];i++){
		  fi[i] = atan2(YintersectionList[i][j]-Oyy,
				XintersectionList[i][j]-Oxx);
		  if( fi[i] > FiStart) fi[i]  -= 2.*PI;
		  if( fi[i] > FiStart) fi[i] = FiStart;
		  auxIndex[i]=i;
		} // end of for( i=0;i<nIntersections[j];i++)
		Merge_Sort( nIntersections[j], fi, auxIndex);
		Xcross[j] = XintersectionList[ auxIndex[nIntersections[j]-1] ][j];
		Ycross[j] = YintersectionList[ auxIndex[nIntersections[j]-1] ][j];
	     }  //   end of for(j=0;j<2;j++)

	  } else {
	     for(j=0;j<2;j++){  // j=0 --> inner polygon; j=1 --> outer polygon.
		UShort_t auxIndex[nIntersections[j]];
		Double_t fi[nIntersections[j]];
		for( i=0;i<nIntersections[j];i++){
		  fi[i] = atan2(YintersectionList[i][j]-Oyy,
				XintersectionList[i][j]-Oxx);
		  if( fi[i] < FiStart) fi[i]  += 2.*PI;
		  if( fi[i] < FiStart) fi[i] = FiStart;
		  auxIndex[i]=i;
		} // end of for( i=0;i<nIntersections[j];i++)
		Merge_Sort( nIntersections[j], fi, auxIndex);
		Xcross[j] = XintersectionList[ auxIndex[0] ][j];
		Ycross[j] = YintersectionList[ auxIndex[0] ][j];
	     }  //   end of for(j=0;j<2;j++)
	  }

	} else{	// therefore it means that flag = 2

	  UShort_t auxIndex[nIntersections[0]];
	  Double_t fi[nIntersections[0]];
	  if(Charge > 0) {
		for( i=0;i<nIntersections[0];i++){
		  fi[i] = atan2(YintersectionList[i][0]-Oyy,
				XintersectionList[i][0]-Oxx);
		  if( fi[i] > FiStart) fi[i]  -= 2.*PI;
		  if( fi[i] > FiStart) fi[i] = FiStart;
		  auxIndex[i]=i;
		} // end of for( i=0;i<nIntersections[0];i++)
		Merge_Sort( nIntersections[0], fi, auxIndex);
		Xcross[0] = XintersectionList[ auxIndex[nIntersections[0]-1] ][0];
		Ycross[0] = YintersectionList[ auxIndex[nIntersections[0]-1] ][0];
		Xcross[1] = XintersectionList[ auxIndex[nIntersections[0]-2] ][0];
		Ycross[1] = YintersectionList[ auxIndex[nIntersections[0]-2] ][0];

	  } else {
		for( i=0;i<nIntersections[0];i++){
		  fi[i] = atan2(YintersectionList[i][0]-Oyy,
				XintersectionList[i][0]-Oxx);
		  if( fi[i] < FiStart) fi[i]  += 2.*PI;
		  if( fi[i] < FiStart) fi[i] = FiStart;
		  auxIndex[i]=i;
		} // end of for( i=0;i<nIntersections[0];i++)
		Merge_Sort( nIntersections[0], fi, auxIndex);
		Xcross[0] = XintersectionList[ auxIndex[0] ][0];
		Ycross[0] = YintersectionList[ auxIndex[0] ][0];
		Xcross[1] = XintersectionList[ auxIndex[1] ][0];
		Ycross[1] = YintersectionList[ auxIndex[1] ][0];
	  }
	}	// end of if(flag == 0)




}
//----------end of function PndSttTrackFinderReal::ChooseEntranceExit








//----------star of function PndSttTrackFinderReal::ChooseEntranceExitbis
	void PndSttTrackFinderReal::ChooseEntranceExitbis(
			Double_t Oxx,
			Double_t Oyy,
			Short_t  Charge,
			Double_t FiStart,
			UShort_t nIntersections,
			Double_t *XintersectionList, //  second index =1 -->inner polygon;
			Double_t *YintersectionList, //  second index =2 -->outer polygon.
			Double_t Xcross[2],	// output
			Double_t Ycross[2]	// output
					)
{

	UShort_t i,
		 j;
// this method works under the hypothesis that there are at least 2 intersections.
	if (nIntersections<2) return;

	  if(Charge > 0) {
		UShort_t auxIndex[nIntersections];
		Double_t fi[nIntersections];
		for( i=0;i<nIntersections;i++){
		  fi[i] = atan2(YintersectionList[i]-Oyy,
				XintersectionList[i]-Oxx);
		  if( fi[i] > FiStart) fi[i]  -= 2.*PI;
		  if( fi[i] > FiStart) fi[i] = FiStart;
		  auxIndex[i]=i;
		} // end of for( i=0;i<nIntersections[j];i++)
		Merge_Sort( nIntersections, fi, auxIndex);
		Xcross[0] = XintersectionList[ auxIndex[nIntersections-1] ];
		Ycross[0] = YintersectionList[ auxIndex[nIntersections-1] ];
		Xcross[1] = XintersectionList[ auxIndex[nIntersections-2] ];
		Ycross[1] = YintersectionList[ auxIndex[nIntersections-2] ];

	  } else {
		UShort_t auxIndex[nIntersections];
		Double_t fi[nIntersections];
		for( i=0;i<nIntersections;i++){
		  fi[i] = atan2(YintersectionList[i]-Oyy,
				XintersectionList[i]-Oxx);
		  if( fi[i] < FiStart) fi[i]  += 2.*PI;
		  if( fi[i] < FiStart) fi[i] = FiStart;
		  auxIndex[i]=i;
		} // end of for( i=0;i<nIntersections;i++)
		Merge_Sort( nIntersections, fi, auxIndex);
		Xcross[0] = XintersectionList[ auxIndex[0] ];
		Ycross[0] = YintersectionList[ auxIndex[0] ];
		Xcross[1] = XintersectionList[ auxIndex[1] ];
		Ycross[1] = YintersectionList[ auxIndex[1] ];
	  }




}
//----------end of function PndSttTrackFinderReal::ChooseEntranceExitbis










//----------begin of function PndSttTrackFinderReal::SeparateInnerOuterParallel

	void PndSttTrackFinderReal::SeparateInnerOuterParallel(

						// input
						UShort_t nHits,
						UShort_t *ListHits,
						Double_t info[][7],
						Double_t RStrawDetInnerParMax,

						// output
						UShort_t *nInnerHits,
						UShort_t *ListInnerHits,
						UShort_t *nOuterHits,
						UShort_t *ListOuterHits
								)
{

	UShort_t ihit;

	Double_t r;

//   separation of inner Parallel Stt hits from outer Parallel Stt hits.

	for(ihit=0,*nInnerHits=0, *nOuterHits=0 ;ihit<nHits;ihit++){
		r = sqrt( info[ListHits[ihit]][0]*info[ListHits[ihit]][0] +
			 info[ListHits[ihit]][1]*info[ListHits[ihit]][1]);
		// the value 2.*RStrawDetectorParMax/sqrt(3.) is because RStrawDetectorParMax
		// is an Apotema !
		if(r>2.*ApotemaMaxInnerParStraw/sqrt(3.) ){	// outer Parallel hit.
			ListOuterHits[ *nOuterHits ] = ListHits[ihit];
			(*nOuterHits)++;
		}else{
			ListInnerHits[ *nInnerHits ] = ListHits[ihit];
			(*nInnerHits)++;
		}
	}

}

//----------end of function PndSttTrackFinderReal::SeparateInnerOuterParallel


//----------begin of function PndSttTrackFinderReal::FindTrackEntranceExitbiHexagon

	Short_t PndSttTrackFinderReal::FindTrackEntranceExitbiHexagon(
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				Double_t ApotemaMin, // Apotema=distance Hexagon side from (0,0).
				Double_t ApotemaMax,
				Double_t Xcross[2],
				Double_t Ycross[2]
							)
{
	Short_t flag;
	UShort_t	nIntersections[2];
	Double_t	FiStart,
			XintersectionList[12][2], // first index =0 --> inner Hexagon, =1 --> outer.
			YintersectionList[12][2]; // second index : all the possible intersections
						  // (up to 12 intersections).

// finding all possible intersections with inner parallel straw region.
// The inner parallel straw region is delimited by two hexagons.

	// flag meaning :
	// -2 -->  track outside outer polygon;
	// -1 -->  track contained completely within inner polygon;
	// 0 -->  at least 1 intersection with inner polygon, at least 1 with outer polygon;
	// 1 -->  track contained completely between the two polygons;
	// 2 -->  track contained completely by larger polygons, with intersections in the smaller;
	// 3 -->  track completely outsiede the small polygon with intersections in the bigger.


	flag=IntersectionsWithClosedPolygon(
		Oxx,
		Oyy,
		Rr,
		ApotemaMin,	// Rmin of the inner part of parallele straws,
		ApotemaMax,// max Apotema of the inner part of parallele straws.
		nIntersections,
		XintersectionList, // XintersectionList[..][0] --> inner polygon,
				   // XintersectionList[..][1] --> outer polygon.
		YintersectionList
					);

	// IMPORTANT :
	// this is true because here it is assumed that the track comes from (0,0,0)
	// otherwise the code must be changed!

	if (!(flag == 0 || flag == 2)) return flag;
	if (flag == 2 &&nIntersections[0]<2 ){
			cout<<"PndSttTrackFinderReal::FindTrackEntranceExitbiHexagon,"<<
			" contraddiction, nIntersections[0]="<<
			nIntersections[0]<<"<2, returning -99!\n";
			return -99;
	}

//-------  among all  possible intersection find the entrance point (Xcross[0], Ycross[0])
//	   and the exit point (Xcross[1], Ycross[1])  of this track.

//-------- the starting point of the track.
	FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);

	// this method selects the entrance and exit points of the trajectory among all
	// geometrical intersections of the circular trajectory with the straw particular
	// volume.

	ChooseEntranceExit(
			Oxx,
			Oyy,
			flag,
			Charge,
			FiStart,
			nIntersections,
			XintersectionList,
			YintersectionList,
			Xcross,	// output
			Ycross	// output
					);

	return flag;

}

//----------end of function PndSttTrackFinderReal::FindTrackEntranceExitbiHexagon




//----------begin of function PndSttTrackFinderReal::FindTrackEntranceExitbiHexagonLeft

	Short_t PndSttTrackFinderReal::FindTrackEntranceExitbiHexagonLeft(
				Double_t vgap,
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				Double_t ApotemaMin, // Apotema=distance Hexagon side from (0,0).
				Double_t ApotemaMax,
				Double_t Xcross[2],
				Double_t Ycross[2]
							)
{
	Short_t flag;
	UShort_t	nIntersections;
	Double_t	FiStart,
			XintersectionList[16], // all the possible intersections
			YintersectionList[16]; // (up to 16 intersections).

// The following is the form of the Left (looking from downstream into the beam) biHexagon
// geometrical shape considered in this method :
//
/*

	      /|
	     / |
	    /  |
	   /  /
	  /  / 
	 /  /  
	/  /   
	|  |   
	|  |   
	|  |   
	|  |   
	\  \   
	 \  \  
	  \  \ 
	   \  \
	    \  |
	     \ |
	      \|

*/
// finding all possible intersections with inner parallel straw region.
// The inner parallel straw region is delimited by two hexagons.

	// flag meaning :
	// -1 -->  track outside outer perimeter;
	// 0 -->  at least 1 intersection with polygon, therefore a possible entry and an exit;
	// 1 -->  track contained completely between the two polygons;


	flag=IntersectionsWithClosedbiHexagonLeft(
		vgap,
		Oxx,
		Oyy,
		Rr,
		ApotemaMin,	// Apotema of the inner Hexagon,
		ApotemaMax,// Apotema of the outer Hexagon.
		&nIntersections,
		XintersectionList, // XintersectionList[..][0] --> inner polygon,
				   // XintersectionList[..][1] --> outer polygon.
		YintersectionList
					);

	// IMPORTANT :
	// this is true because here it is assumed that the track comes from (0,0,0)
	// otherwise the code must be changed!

	if (!(flag == 0)) return flag;
	if( nIntersections<2) return -1;

//-------  among all  possible intersection find the entrance point (Xcross[0], Ycross[0])
//	   and the exit point (Xcross[1], Ycross[1])  of this track.

//-------- the starting point of the track.
	FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);

	// this method selects the entrance and exit points of the trajectory among all
	// geometrical intersections of the circular trajectory with the straw particular
	// volume.

	// so at this point, the intersections are at least 2.

	ChooseEntranceExitbis(
			Oxx,
			Oyy,
			Charge,
			FiStart,
			nIntersections,
			XintersectionList,
			YintersectionList,
			Xcross,	// output
			Ycross	// output
					);


//----------------------

	return flag;

}

//----------end of function PndSttTrackFinderReal::FindTrackEntranceExitbiHexagonLeft









//----------begin of function PndSttTrackFinderReal::FindTrackEntranceExitbiHexagonRight


	Short_t PndSttTrackFinderReal::FindTrackEntranceExitbiHexagonRight(
				Double_t vgap,
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				Double_t ApotemaMin, // Apotema=distance Hexagon side from (0,0).
				Double_t ApotemaMax,
				Double_t Xcross[2],
				Double_t Ycross[2]
							)
{
	Short_t flag;
	UShort_t	nIntersections;
	Double_t	FiStart,
			XintersectionList[16], // all the possible intersections
			YintersectionList[16]; // (up to 16 intersections).

// The following is the form of the Left (looking from downstream into the beam) biHexagon
// geometrical shape considered in this method :
//
/*
	|\
	| \
	|  \
	 \  \
	  \  \
	   |  |
	   |  |
	   /  /
	  /  /
	 /  /
	|  /
	| /
	|/
*/

// finding all possible intersections with inner parallel straw region.
// The inner parallel straw region is delimited by two hexagons.

	// flag meaning :
	// -1 -->  track outside outer perimeter;
	// 0 -->  at least 1 intersection with polygon, therefore a possible entry and an exit;
	// 1 -->  track contained completely between the two polygons;


	flag=IntersectionsWithClosedbiHexagonRight(
		vgap,
		Oxx,
		Oyy,
		Rr,
		ApotemaMin,	// Apotema of the inner Hexagon,
		ApotemaMax,// Apotema of the outer Hexagon.
		&nIntersections,
		XintersectionList, // XintersectionList[..][0] --> inner polygon,
				   // XintersectionList[..][1] --> outer polygon.
		YintersectionList
					);

	// IMPORTANT :
	// this is true because here it is assumed that the track comes from (0,0,0)
	// otherwise the code must be changed!

	if (!(flag == 0)) return flag;
	if( nIntersections<2) return -1;

//-------  among all  possible intersection find the entrance point (Xcross[0], Ycross[0])
//	   and the exit point (Xcross[1], Ycross[1])  of this track.

//-------- the starting point of the track.
	FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);

	// this method selects the entrance and exit points of the trajectory among all
	// geometrical intersections of the circular trajectory with the straw particular
	// volume.

	// so at this point, the intersections are at least 2.

	ChooseEntranceExitbis(
			Oxx,
			Oyy,
			Charge,
			FiStart,
			nIntersections,
			XintersectionList,
			YintersectionList,
			Xcross,	// output
			Ycross	// output
					);


//----------------------

	return flag;

}


//----------end of function PndSttTrackFinderReal::FindTrackEntranceExitbiHexagonRight










//----------begin of function PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircle


	Short_t PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircle(
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				Double_t ApotemaMin, // Apotema=distance Hexagon side from (0,0).
				Double_t ApotemaMax,
				Double_t Xcross[2],
				Double_t Ycross[2]
							)
{
	Short_t flag;
	UShort_t	nIntersections[2];
	Double_t	FiStart,
			XintersectionList[12][2], // second index =0 --> inner Hexagon, =1 --> outer.
			YintersectionList[12][2]; // first index : all the possible intersections
						  // (up to 12 intersections).

// finding all possible intersections with inner parallel straw region.
// The inner parallel straw region is delimited by two hexagons.

	// flag meaning :
	// -2 -->  track outside outer polygon;
	// -1 -->  track contained completely within inner polygon;
	// 0 -->  at least 1 intersection with inner polygon, at least 1 with outer polygon;
	// 1 -->  track contained completely between the two polygons;
	// 2 -->  track contained completely by larger polygons, with intersections in the smaller;
	// 3 -->  track completely outsiede the small polygon with intersections in the bigger.


	flag=IntersectionsWithClosedPolygon(
		Oxx,
		Oyy,
		Rr,
		ApotemaMin,	// Rmin of the inner part of parallele straws,
		ApotemaMax,// max Apotema of the inner part of parallele straws.
		nIntersections,
		XintersectionList, // XintersectionList[..][0] --> inner polygon,
				   // XintersectionList[..][1] --> outer polygon.
		YintersectionList
					);

	// IMPORTANT :
	// this is true because here it is assumed that the track comes from (0,0,0)
	// otherwise the code must be changed!

	if (!(flag == 0 || flag == 2)) return flag;
	if (flag == 2 &&nIntersections[0]<2 ){
			cout<<"PndSttTrackFinderReal::FindTrackEntranceExitbiHexagon,"<<
			" contraddiction, nIntersections[0]="<<
			nIntersections[0]<<"<2, returning -99!\n";
			return -99;
	}

//-------  among all  possible intersection find the entrance point (Xcross[0], Ycross[0])
//	   and the exit point (Xcross[1], Ycross[1])  of this track.

//-------- the starting point of the track.
	FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);

	// this method selects the entrance and exit points of the trajectory among all
	// geometrical intersections of the circular trajectory with the straw particular
	// volume.

	ChooseEntranceExit(
			Oxx,
			Oyy,
			flag,
			Charge,
			FiStart,
			nIntersections,
			XintersectionList,
			YintersectionList,
			Xcross,	// output
			Ycross	// output
					);

//----------------------

	return flag;

}

//----------end of function PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircle










//----------begin of function PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircleLeft


	Short_t PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircleLeft(
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				Double_t ApotemaMin, // Apotema=distance Hexagon side from (0,0).
				Double_t Rma, // outer radius of the Circle.
				Double_t GAP,
				Double_t Xcross[2],
				Double_t Ycross[2]
							)
{

//  This methods finds the intersections between a trajectory coming from (0,0) and
//  parameters  Oxx, Oyy, Rr   with the closed geometrical figure (in XY) formed by the STT
//  external Left semicircle and the Outer STT parallel Left straw semi-Hexagon + Gap for
//  the pellet target target.
//  It returns -1 if there are 0 or 1 intersections, 0 if there are at least 2 intersections.


	Double_t	cosFi,
			theta1,
			theta2,
			Theta1,
			Theta2,
			aaa,
			Fi,
			FI0,
			x1,
			x2,
			y1,
			y2;
//------------------

	UShort_t	nIntersectionsCircle,
			nIntersections;
	Double_t	FiStart,
			XintersectionList[12],
			YintersectionList[12]; // all the possible intersections (up to 12 intersections).

// finding all possible intersections with inner parallel straw region.


	Double_t Side_x[] = {	-GAP/2., -GAP/2. , -ApotemaMin, -ApotemaMin, -GAP/2., -GAP/2. },
		 Side_y[] = {	sqrt(Rma*Rma-GAP*GAP/4.),  (2.*ApotemaMin-GAP)/sqrt(3.),
				ApotemaMin/sqrt(3.),
				-ApotemaMin/sqrt(3.),
				-(2.*ApotemaMin-GAP)/sqrt(3.), -sqrt(Rma*Rma-GAP*GAP/4.)},
		 a[] =	{1.,		-1./sqrt(3.),	1.,	1./sqrt(3.),	1.},
		 b[] =	{0.,		1.,		0.,	1.,		0.},
		 c[] =	{GAP/2., -2.*ApotemaMin/sqrt(3.),ApotemaMin, 2.*ApotemaMin/sqrt(3.), GAP/2.};

	nIntersections=IntersectionsWithOpenPolygon(
		Oxx,
		Oyy,
		Rr,
		5, //  n. Sides of open Polygon.
		a, //  coefficient of formula :  aX + bY + c = 0 defining the Polygon sides.
		b,
		c,
		Side_x,  // X,Y coordinate of the Sides vertices (in sequence, following
		Side_y,  // the Polygon along.
		XintersectionList, // XintersectionList
		YintersectionList // YintersectionList.
					);




//-------------------------------------------------------------------------
// finding intersections of trajectory [assumed to originate from (0,0) ]
// with outer semicircle, the Left part.

	nIntersectionsCircle=IntersectionsWithGapSemicircle(
		Oxx, // input from trajectory
		Oyy, // input from trajectory
		Rr, // input from trajectory
		GAP, // input, vertical gap in XY plane of STT detector.
		true, // true --> Left semicircle, false --> Right semicircle.
		Rma, // radius of external Stt containment.
		&XintersectionList[nIntersections], // output, X list of intersections (maximal 2).
		&YintersectionList[nIntersections]
						);
	nIntersections += nIntersectionsCircle;

//-------- the starting point of the track.

	if(nIntersections<2) return -1;

	FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);

	// this method selects the entrance and exit points of the trajectory among all
	// geometrical intersections of the circular trajectory with the straw particular
	// volume.


	ChooseEntranceExitbis(
			Oxx,
			Oyy,
			Charge,
			FiStart,
			nIntersections,
			XintersectionList,
			YintersectionList,
			Xcross,	// output
			Ycross	// output
					);


	return 0;

}

//----------end of function PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircleLeft












//----------begin of function PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircleRight


	Short_t PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircleRight(
				Double_t Oxx,
				Double_t Oyy,
				Double_t Rr,
				Short_t  Charge,
				Double_t Start[3],
				Double_t ApotemaMin, // Apotema=distance Hexagon side from (0,0).
				Double_t Rma, // outer radius of the Circle.
				Double_t GAP,
				Double_t Xcross[2],
				Double_t Ycross[2]
							)
{

//  This methods finds the intersections between a trajectory coming from (0,0) and
//  parameters  Oxx, Oyy, Rr   with the closed geometrical figure (in XY) formed by the STT
//  external Left semicircle and the Outer STT parallel Left straw semi-Hexagon + Gap for
//  the pellet target target.
//  It returns -1 if there are 0 or 1 intersections, 0 if there are at least 2 intersections.


	Double_t	cosFi,
			theta1,
			theta2,
			Theta1,
			Theta2,
			aaa,
			Fi,
			FI0,
			x1,
			x2,
			y1,
			y2;
//------------------

	UShort_t	nIntersectionsCircle,
			nIntersections;
	Double_t	FiStart,
			XintersectionList[12],
			YintersectionList[12]; // all the possible intersections (up to 10 intersections).

// finding all possible intersections with inner parallel straw region.


	Double_t Side_x[] = {	GAP/2., GAP/2. , ApotemaMin, ApotemaMin, GAP/2., GAP/2. },
		 Side_y[] = {	sqrt(Rma*Rma-GAP*GAP/4.),  (2.*ApotemaMin-GAP)/sqrt(3.),
				ApotemaMin/sqrt(3.),
				-ApotemaMin/sqrt(3.),
				-(2.*ApotemaMin-GAP)/sqrt(3.), -sqrt(Rma*Rma-GAP*GAP/4.)},
		 a[] =	{1.,		1./sqrt(3.),	1.,	-1./sqrt(3.),	1.},
		 b[] =	{0.,		1.,		0.,	1.,		0.},
		 c[] =	{-GAP/2.,-2.*ApotemaMin/sqrt(3.),-ApotemaMin, 2.*ApotemaMin/sqrt(3.), -GAP/2.};

	nIntersections=IntersectionsWithOpenPolygon(
		Oxx,
		Oyy,
		Rr,
		5, //  n. Sides of open Polygon.
		a, //  coefficient of formula :  aX + bY + c = 0 defining the Polygon sides.
		b,
		c,
		Side_x,  // X,Y coordinate of the Sides vertices (in sequence, following
		Side_y,  // the Polygon along.
		XintersectionList, // XintersectionList
		YintersectionList // YintersectionList.
					);



//-------------------------------------------------------------------------
// finding intersections of trajectory [assumed to originate from (0,0) ]
// with outer semicircle, the Left part.

	nIntersectionsCircle=IntersectionsWithGapSemicircle(
		Oxx, // input from trajectory
		Oyy, // input from trajectory
		Rr, // input from trajectory
		GAP, // input, vertical gap in XY plane of STT detector.
		false, // true --> Left semicircle, false --> Right semicircle.
		Rma, // radius of external Stt containment.
		&XintersectionList[nIntersections], // output, X list of intersections (maximal 2).
		&YintersectionList[nIntersections]
						);


	nIntersections += nIntersectionsCircle;

//-------- the starting point of the track.

	if(nIntersections<2) return -1;

	FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);

	// this method selects the entrance and exit points of the trajectory among all
	// geometrical intersections of the circular trajectory with the straw particular
	// volume.

	ChooseEntranceExitbis(
			Oxx,
			Oyy,
			Charge,
			FiStart,
			nIntersections,
			XintersectionList,
			YintersectionList,
			Xcross,	// output
			Ycross	// output
					);


	return 0;

}

//----------end of function PndSttTrackFinderReal::FindTrackEntranceExitHexagonCircleRight

ClassImp(PndSttTrackFinderReal)