docs: def TPAGB_properties(self):
  
          """
          Temporary, use for now same function in nugrid_set.py!
          Returns many TPAGB parameters which are
          TPstart,TPmods,TP_max_env,TPend,min_m_TP,max_m_TP,DUPmods,DUPm_min_h
          Same function in nugrid_set.py.
  
          Parameters
          ----------
  
          """
  
          peak_lum_model,h1_mass_min_DUP_model=self.find_TP_attributes( 3, t0_model=self.find_first_TP(), color='r', marker_type='o')
  
          print('first tp')
          print(self.find_first_TP())
          print('peak lum mmmodel')
          print(peak_lum_model)
          print(h1_mass_min_DUP_model)
  
          TPmods=peak_lum_model
  
          DUPmods=h1_mass_min_DUP_model
          DUPmods1=[]
          for k in range(len(DUPmods)):
                  DUPmods1.append(int(float(DUPmods[k]))+100) #to exclude HBB? effects
  
          DUPmods=DUPmods1
  
  
  
          TPstart=[]
          #find beginning of TP, goes from TP peak backwards
          # find end of PDCZ by seeking from TP peak and checking mx2_bot:
          models=self.get('model_number')
          mx2b_array=self.get('conv_mx2_bot')
          mx2t_array=self.get('conv_mx2_top')
          massbot=mx2b_array#*self.header_attr['initial_mass']
          masstop=mx2t_array#*self.header_attr['initial_mass']
          massenv=np.array(self.get('conv_mx1_bot'))*np.array(self.get('star_mass'))   #*self.header_attr['initial_mass']
  
          #h1_bdy=self.get('h1_boundary_mass')
  
          for k in range(len(TPmods)):
                  idx=list(models).index(TPmods[k])
                  mx2b=mx2b_array[:idx]
                  for i in range(len(mx2b)-1,0,-1):
                          if mx2b[i]==0.:
                              startTP=models[i]
                              TPstart.append(int(float(startTP)))
                              break
          #Find end of TP, goes from TP forwards:
          TPend=[]
          max_m_TP=[]
          min_m_TP=[]
          DUP_m=[]
          TP_max_env=[]
          DUPm_min_h=[]
          flagdecline=False
          for k in range(len(TPmods)):
              idx=list(models).index(TPmods[k])
              mx2b=mx2b_array[idx:]
              mx2t=mx2t_array[idx:]
              refsize=mx2t[0]-mx2b[0]
              for i in range(len(mx2b)):
                  if i==0:
                      continue
                  if ((mx2t[i]-mx2b[i])<(0.5*refsize)) and (flagdecline==False):
                      flagdecline=True
                      refmasscoord=mx2t[i]
                      print('flagdecline to true')
                      continue
                  if flagdecline==True:
                      if (mx2t[i]-mx2b[i])<(0.1*refsize):
                          #for the massive and HDUP AGB's where PDCZ conv zone becomes the Hdup CONV ZONE
                          if refmasscoord<mx2t[i]:
                              endTP=models[idx+i-1]
                              TPend.append(int(float(endTP)))
                              print('HDUp, TP end',endTP)
                              break
                          if (mx2t[i]-mx2b[i])<1e-5:
                              endTP=models[idx+i-1]
                              TPend.append(int(float(endTP)))
                              print('normal TPend',endTP)
                              break
  
                  # if max(mx2t[0:(i-1)])>mx2t[i]:
                  #         (max(mx2t[0:(i-1)]) - min(mx2b[0:(i-1)]))
                  #         flag=True
                  #         continue
                  # if flag==True:
                  #     endidx=idx+i
                  #     endTP=models[endidx]
                  #     TPend.append(int(float(endTP)))
  
                  # if (mx2t[i]-mx2b[i])<1e-5:                        #mx2b[i])==0.:
                  #     endidx=idx+i
                  #     endTP=models[endidx]
                  #     TPend.append(int(float(endTP)))
                  #     break
  
              print('found TP boundaries',TPstart[-1],TPend[-1])
          #find max and minimum mass coord of TP at max Lum
              mtot=self.get('star_mass')
              masstop_tot=np.array(masstop)*np.array(mtot)
              idx_tpext=list(masstop_tot).index(max(masstop_tot[TPstart[k]:(TPend[k]-10)]))
              print('TP',k+1,TPmods[k])
              print(TPstart[k],TPend[k])
              print('INDEX',idx_tpext,models[idx_tpext])
              print(max(masstop_tot[TPstart[k]:(TPend[k]-10)]))
              mtot=self.get('star_mass')[idx_tpext]
              max_m_TP.append(masstop[idx_tpext]*mtot)
              min_m_TP.append(massbot[idx_tpext]*mtot)
  
              TP_max_env.append(massenv[idx_tpext])#*mtot)
              if k> (len(DUPmods)-1):
                      continue
              idx=list(models).index(DUPmods[k])
              mtot=self.get('star_mass')[idx]
              #DUP_m.append(h1_bdy[idx])#*mtot)
          #######identify if it is really a TDUP, Def.
              try:
                  h1_bndry=self.get("h1_boundary_mass")[t0_idx:]
              except:
                  try:
                      h1_bndry=self.get('he_core_mass')[t0_idx:]
                  except:
                      pass
  
              if h1_bndry[idx]>=max_m_TP[-1]:
                  print('Pulse',k+1,'model',TPmods[k],'skip')
                  print(h1_bndry[idx],max_m_TP[-1])
                  DUPmods[k] = -1
                  DUPm_min_h.append( -1)
                  continue
  
              DUPm_min_h.append(h1_bdy[idx])
          for k in range(len(TPmods)):
              print('#############')
              print('TP ',k+1)
              print('Start: ',TPstart[k])
              print('Peak' , TPmods[k],TP_max_env[k])
              print('(conv) PDCZ size: ',min_m_TP[k],' till ',max_m_TP[k])
              print('End',TPend[k])
              if k <=(len(DUPmods)-1):
                  print(len(DUPmods),k)
                  print('DUP max',DUPmods[k])
                  print(DUPm_min_h[k])
              else:
                  print('no DUP')
  
              return TPstart,TPmods,TP_max_env,TPend,min_m_TP,max_m_TP,DUPmods,DUPm_min_h